Code

Adding crop feature in ncmpc
[ncmpc.git] / src / command.c
index 1d77d0d2d4b9d4a413e387c1e4049ed786cddc7e..0ae90338194157da3b30e2c1f1f1eebf97cfff6f 100644 (file)
  *
  */
 
+#include "command.h"
+#include "config.h"
+#include "ncmpc.h"
+#include "mpdclient.h"
+#include "screen.h"
+
 #include <ctype.h>
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
 #include <glib.h>
-#include <ncurses.h>
-
-#include "config.h"
-#include "ncmpc.h"
-#include "command.h"
+#include <signal.h>
+#include <unistd.h>
 
 #undef DEBUG_KEYS
 
@@ -38,8 +40,6 @@
 #define DK(x)
 #endif
 
-extern void screen_resize(void);
-
 #define BS   KEY_BACKSPACE
 #define DEL  KEY_DC
 #define UP   KEY_UP
@@ -59,6 +59,7 @@ extern void screen_resize(void);
 #define F4   KEY_F(4)
 #define F5   KEY_F(5)
 #define F6   KEY_F(6)
+#define F7   KEY_F(7)
 
 
 static command_definition_t cmds[] =
@@ -101,6 +102,8 @@ static command_definition_t cmds[] =
     N_("Pause") },
   { { 's',  BS,   0 }, 0, CMD_STOP, "stop",   
     N_("Stop") },
+  { { 'o',  0,   0 }, 0, CMD_CROP, "crop",
+    N_("Crop") },
   { { '>',   0,   0 }, 0, CMD_TRACK_NEXT, "next", 
     N_("Next track") },
   { { '<',   0,   0 }, 0, CMD_TRACK_PREVIOUS, "prev", 
@@ -115,6 +118,8 @@ static command_definition_t cmds[] =
     N_("Decrease volume") },
   { { ' ',   0,   0 }, 0, CMD_SELECT, "select", 
     N_("Select/deselect song in playlist") },
+  { { 't',   0,   0 }, 0, CMD_SELECT_ALL, "select_all",
+    N_("Select all listed items") },
   { { DEL,  'd',  0 }, 0, CMD_DELETE, "delete",
     N_("Delete song from playlist") },
   { { 'Z',   0,   0 }, 0, CMD_SHUFFLE, "shuffle",
@@ -134,6 +139,10 @@ static command_definition_t cmds[] =
   { { 'a',   0,   0 }, 0, CMD_ADD, "add",
     N_("Add url/file to playlist") },
 
+  { { '!',   0,   0 }, 0, CMD_GO_ROOT_DIRECTORY, "go-root-directory",
+    N_("Go to root directory") },
+  { { '"',   0,   0 }, 0, CMD_GO_PARENT_DIRECTORY, "go-parent-directory",
+    N_("Go to parent directory") },
 
   /* lists */
   { { 11,  0,   0 }, 0, CMD_LIST_MOVE_UP,     "move-up", 
@@ -170,349 +179,362 @@ static command_definition_t cmds[] =
 
 
   /* extra screens */
-#ifdef ENABLE_CLOCK_SCREEN
-  { {'4',  F4,   0 }, 0, CMD_SCREEN_CLOCK,    "screen-clock",
-    N_("Clock screen") },
+#ifdef ENABLE_ARTIST_SCREEN
+  { {'4',  F4,   0 }, 0, CMD_SCREEN_ARTIST,    "screen-artist",
+    N_("Artist screen") },
+#endif
+#ifdef ENABLE_SEARCH_SCREEN
+  { {'5',  F5,   0 }, 0, CMD_SCREEN_SEARCH,    "screen-search",
+    N_("Search screen") },
+  { {'m',   0,   0 }, 0, CMD_SEARCH_MODE,      "search-mode",
+    N_("Change search mode") },
+#endif
+
+#ifdef ENABLE_LYRICS_SCREEN
+  { {'7',  F7,   0 }, 0, CMD_SCREEN_LYRICS,    "screen-lyrics",
+    N_("Lyrics screen") },
+  { {ESC,  0,   0 }, 0, CMD_INTERRUPT,    "lyrics-interrupt",
+    N_("Interrupt action") },
+  { {'u',  0,   0 }, 0, CMD_LYRICS_UPDATE,    "lyrics-update",
+    N_("Update Lyrics") },
 #endif
 
+
   { { -1,  -1,  -1 }, 0, CMD_NONE, NULL, NULL }
 };
 
 command_definition_t *
 get_command_definitions(void)
 {
-  return cmds;
+       return cmds;
 }
 
-char *
+const char *
 key2str(int key)
 {
-  static char buf[32];
-  int i;
+       static char buf[32];
+       int i;
+
+       buf[0] = 0;
+       switch(key) {
+       case 0:
+               return _("Undefined");
+       case ' ':
+               return _("Space");
+       case 13:
+               return _("Enter");
+       case BS:
+               return _("Backspace");
+       case DEL:
+               return _("Delete");
+       case UP:
+               return _("Up");
+       case DWN:
+               return _("Down");
+       case LEFT:
+               return _("Left");
+       case RGHT:
+               return _("Right");
+       case HOME:
+               return _("Home");
+       case END:
+               return _("End");
+       case PGDN:
+               return _("PageDown");
+       case PGUP:
+               return _("PageUp");
+       case TAB:
+               return _("Tab");
+       case STAB:
+               return _("Shift+Tab");
+       case ESC:
+               return _("Esc");
+       case KEY_IC:
+               return _("Insert");
+       default:
+               for (i = 0; i <= 63; i++)
+                       if (key == KEY_F(i)) {
+                               g_snprintf(buf, 32, "F%d", i );
+                               return buf;
+                       }
+               if (!(key & ~037))
+                       g_snprintf(buf, 32, "Ctrl-%c", 'A'+(key & 037)-1 );
+               else if ((key & ~037) == 224)
+                       g_snprintf(buf, 32, "Alt-%c", 'A'+(key & 037)-1 );
+               else if (key > 32 && key < 256)
+                       g_snprintf(buf, 32, "%c", key);
+               else
+                       g_snprintf(buf, 32, "0x%03X", key);
+       }
 
-  buf[0] = 0;
-  switch(key)
-    {
-    case 0:
-      return _("Undefined");
-    case ' ':
-      return _("Space");
-    case 13:
-      return _("Enter");
-    case BS:
-      return _("Backspace");
-    case DEL:
-      return _("Delete");
-    case UP: 
-      return _("Up");
-    case DWN:
-      return _("Down");
-    case LEFT:
-      return _("Left");
-    case RGHT:
-      return _("Right");
-    case HOME:
-      return _("Home");
-    case END:
-      return _("End");
-    case PGDN:
-      return _("PageDown");
-    case PGUP:
-      return _("PageUp");
-    case TAB: 
-      return _("Tab");
-    case STAB:
-      return _("Shift+Tab");
-    case ESC:
-      return _("Esc");
-    case KEY_IC:
-      return _("Insert");
-    default:
-      for(i=0; i<=63; i++)
-       if( key==KEY_F(i) )
-         {
-           snprintf(buf, 32, "F%d", i );
-           return buf;
-         }
-      if( !(key & ~037) )
-       snprintf(buf, 32, "Ctrl-%c", 'A'+(key & 037)-1 );
-      else if( (key & ~037) == 224 )
-       snprintf(buf, 32, "Alt-%c", 'A'+(key & 037)-1 );
-      else if( key>32 &&  key<256 )
-       snprintf(buf, 32, "%c", key);
-      else
-       snprintf(buf, 32, "0x%03X", key);
-    }
-  return buf;
+       return buf;
 }
 
 void
 command_dump_keys(void)
 {
-  int i;
+       int i;
 
-  i=0;
-  while( cmds[i].description )
-    {
-      if( cmds[i].command != CMD_NONE )
-       printf(" %20s : %s\n", get_key_names(cmds[i].command,1),cmds[i].name); 
-      i++;
-    }
+       i = 0;
+       while (cmds[i].description) {
+               if (cmds[i].command != CMD_NONE)
+                       printf(" %20s : %s\n", get_key_names(cmds[i].command,1),cmds[i].name);
+               i++;
+       }
 }
 
-int
+static int
 set_key_flags(command_definition_t *cp, command_t command, int flags)
 {
-  int i;
+       int i;
 
-  i=0;
-  while( cp[i].name )
-    {
-      if( cp[i].command == command )
-       {
-         cp[i].flags |= flags;
-         return 0;
+       i = 0;
+       while (cp[i].name) {
+               if (cp[i].command == command) {
+                       cp[i].flags |= flags;
+                       return 0;
+               }
+               i++;
        }
-      i++;
-    }
-  return 1;
+
+       return 1;
 }
 
-char *
+const char *
 get_key_names(command_t command, int all)
 {
   int i;
-  
+
   i=0;
-  while( cmds[i].description )
-    {
-      if( cmds[i].command == command )
-       {
-         int j;
-         static char keystr[80];
-
-         strncpy(keystr, key2str(cmds[i].keys[0]), 80);
-         if( !all )
-           return keystr;
-         j=1;
-         while( j<MAX_COMMAND_KEYS && cmds[i].keys[j]>0 )
-           {
-             strcat(keystr, " ");
-             strcat(keystr, key2str(cmds[i].keys[j]));
-             j++;
-           }
-         return keystr;
-       }
-      i++;
-    }
+  while (cmds[i].description) {
+         if (cmds[i].command == command) {
+                 int j;
+                 static char keystr[80];
+
+                 g_strlcpy(keystr, key2str(cmds[i].keys[0]), sizeof(keystr));
+                 if (!all)
+                         return keystr;
+                 j=1;
+                 while (j < MAX_COMMAND_KEYS && cmds[i].keys[j] > 0) {
+                         g_strlcat(keystr, " ", sizeof(keystr));
+                         g_strlcat(keystr, key2str(cmds[i].keys[j]), sizeof(keystr));
+                         j++;
+                 }
+                 return keystr;
+         }
+         i++;
+  }
   return NULL;
 }
 
-char *
+const char *
 get_key_description(command_t command)
 {
-  int i;
+       int i;
 
-  i=0;
-  while( cmds[i].description )
-    {
-      if( cmds[i].command == command )
-       return _(cmds[i].description);
-      i++;
-    }
-  return NULL;
+       i=0;
+       while (cmds[i].description) {
+               if (cmds[i].command == command)
+                       return _(cmds[i].description);
+               i++;
+       }
+
+       return NULL;
 }
 
-char *
+const char *
 get_key_command_name(command_t command)
 {
-  int i;
+       int i;
 
-  i=0;
-  while( cmds[i].name )
-    {
-      if( cmds[i].command == command )
-       return cmds[i].name;
-      i++;
-    }
-  return NULL;
+       i=0;
+       while (cmds[i].name) {
+               if (cmds[i].command == command)
+                       return cmds[i].name;
+               i++;
+       }
+       return NULL;
 }
 
-command_t 
+command_t
 get_key_command_from_name(char *name)
 {
-  int i;
+       int i;
 
-  i=0;
-  while( cmds[i].name )
-    {
-      if( strcmp(name, cmds[i].name) == 0 )
-       return cmds[i].command;
-      i++;
-    }
-  return CMD_NONE;
-}
+       i=0;
+       while (cmds[i].name) {
+               if (strcmp(name, cmds[i].name) == 0)
+                       return cmds[i].command;
+               i++;
+       }
 
+       return CMD_NONE;
+}
 
-command_t 
-find_key_command(int key, command_definition_t *cmds)
+command_t
+find_key_command(int key, command_definition_t *c)
 {
-  int i;
+       int i;
+
+       i=0;
+       while (key && c && c[i].name) {
+               if (c[i].keys[0] == key ||
+                   c[i].keys[1] == key ||
+                   c[i].keys[2] == key)
+                       return c[i].command;
+               i++;
+       }
 
-  i=0;
-  while( cmds && cmds[i].name )
-    {
-      if( cmds[i].keys[0] == key || 
-         cmds[i].keys[1] == key ||
-         cmds[i].keys[2] == key )
-       return cmds[i].command;
-      i++;
-    }
-  return CMD_NONE;
+       return CMD_NONE;
 }
 
-command_t 
+command_t
 get_key_command(int key)
 {
-  return find_key_command(key, cmds);
+       return find_key_command(key, cmds);
 }
 
-command_t
-get_keyboard_command_with_timeout(int ms)
+int
+my_wgetch(WINDOW *w)
 {
-  int key;
-
-  if( ms != SCREEN_TIMEOUT)
-    timeout(ms);
-  key = wgetch(stdscr);
-  if( ms != SCREEN_TIMEOUT)
-    timeout(SCREEN_TIMEOUT);
+       int c;
 
-  if( key==KEY_RESIZE )
-    screen_resize();
+       c = wgetch(w);
 
-  if( key==ERR )
-    return CMD_NONE;
+       /* handle resize event */
+       if (c == KEY_RESIZE)
+               screen_resize();
 
-#ifdef HAVE_GETMOUSE
-  if( key==KEY_MOUSE )
-    return CMD_MOUSE_EVENT;
+#ifdef ENABLE_RAW_MODE
+       /* handle SIGSTOP (Ctrl-Z) */
+       if (c == 26 || c == 407)
+               sigstop();
+       /* handle SIGINT (Ctrl-C) */
+       if (c == 3)
+               kill(getpid(), SIGTERM);
 #endif
 
-  return get_key_command(key);
+       return c;
 }
 
 command_t
 get_keyboard_command(void)
 {
-  return get_keyboard_command_with_timeout(SCREEN_TIMEOUT);
+       int key;
+
+       key = my_wgetch(stdscr);
+       if (key == ERR)
+               return CMD_NONE;
+
+#ifdef HAVE_GETMOUSE
+       if (key == KEY_MOUSE)
+               return CMD_MOUSE_EVENT;
+#endif
+
+       return get_key_command(key);
 }
 
 int
 assign_keys(command_t command, int keys[MAX_COMMAND_KEYS])
 {
- int i;
-
-  i=0;
-  while( cmds[i].name )
-    {
-      if( cmds[i].command == command )
-       {
-         memcpy(cmds[i].keys, keys, sizeof(int)*MAX_COMMAND_KEYS);
-         cmds[i].flags |= COMMAND_KEY_MODIFIED;
-         return 0;
      int i;
+
+       i=0;
+       while (cmds[i].name) {
+               if (cmds[i].command == command) {
+                       memcpy(cmds[i].keys, keys, sizeof(int)*MAX_COMMAND_KEYS);
+                       cmds[i].flags |= COMMAND_KEY_MODIFIED;
+                       return 0;
+               }
+               i++;
        }
-      i++;
-    }
-  return -1;
+       return -1;
 }
 
-int 
+int
 check_key_bindings(command_definition_t *cp, char *buf, size_t bufsize)
 {
-  int i;
-  int retval = 0;
+       int i;
+       int retval = 0;
 
-  if( cp==NULL )
-    cp = cmds;
+       if (cp == NULL)
+               cp = cmds;
 
-  i=0;
-  while( cp[i].name )
-    {
-      cp[i].flags &= ~COMMAND_KEY_CONFLICT;
-      i++;
-    }
-  
-  i=0;
-  while( cp[i].name )
-    {
-      int j;
-      command_t cmd;     
-
-      for(j=0; j<MAX_COMMAND_KEYS; j++)
-       if( cp[i].keys[j] && 
-           (cmd=find_key_command(cp[i].keys[j],cp)) != cp[i].command )
-         {
-           if( buf )
+       i=0;
+       while (cp[i].name) {
+               cp[i].flags &= ~COMMAND_KEY_CONFLICT;
+               i++;
+       }
+
+       i=0;
+       while (cp[i].name) {
+               int j;
+               command_t cmd;
+
+               for(j=0; j<MAX_COMMAND_KEYS; j++)
+                       if (cp[i].keys[j] &&
+                           (cmd = find_key_command(cp[i].keys[j],cp)) != cp[i].command) {
+                               if (buf) {
 #ifdef ENABLE_KEYDEF_SCREEN
-             snprintf(buf, bufsize,
-                      _("Key %s assigned to %s and %s (press %s for the key editor)"),
-                      key2str(cp[i].keys[j]),
-                      get_key_command_name(cp[i].command),
-                      get_key_command_name(cmd),
-                      get_key_names(CMD_SCREEN_KEYDEF,0));
+                                       g_snprintf(buf, bufsize,
+                                                  _("Key %s assigned to %s and %s (press %s for the key editor)"),
+                                                  key2str(cp[i].keys[j]),
+                                                  get_key_command_name(cp[i].command),
+                                                  get_key_command_name(cmd),
+                                                  get_key_names(CMD_SCREEN_KEYDEF,0));
 #else
-           snprintf(buf, bufsize,
-                      _("Error: Key %s assigned to %s and %s !!!\n"),
-                      key2str(cp[i].keys[j]),
-                      get_key_command_name(cp[i].command),
-                      get_key_command_name(cmd));
+                                       g_snprintf(buf, bufsize,
+                                                  _("Error: Key %s assigned to %s and %s !!!\n"),
+                                                  key2str(cp[i].keys[j]),
+                                                  get_key_command_name(cp[i].command),
+                                                  get_key_command_name(cmd));
 #endif
-           else
-             fprintf(stderr,
-                     _("Error: Key %s assigned to %s and %s !!!\n"),
-                     key2str(cp[i].keys[j]),
-                     get_key_command_name(cp[i].command),
-                     get_key_command_name(cmd));
-           cp[i].flags |= COMMAND_KEY_CONFLICT;
-           set_key_flags(cp, cmd, COMMAND_KEY_CONFLICT);
-           retval = -1;
-         }     
-      i++;
-    }
-  return retval;
+                               } else
+                                       fprintf(stderr,
+                                               _("Error: Key %s assigned to %s and %s !!!\n"),
+                                               key2str(cp[i].keys[j]),
+                                               get_key_command_name(cp[i].command),
+                                               get_key_command_name(cmd));
+                               cp[i].flags |= COMMAND_KEY_CONFLICT;
+                               set_key_flags(cp, cmd, COMMAND_KEY_CONFLICT);
+                               retval = -1;
+                       }
+               i++;
+       }
+       return retval;
 }
 
 int
-write_key_bindings(FILE *f)
+write_key_bindings(FILE *f, int flags)
 {
-  int i,j;
-
-  fprintf(f, "# Key bindings for ncmpc (generated by ncmpc)\n\n");
-
-  i=0;
-  while( cmds[i].name && !ferror(f) )
-    {
-      if( cmds[i].flags & COMMAND_KEY_MODIFIED )
-       {
-         fprintf(f, "# %s\n", cmds[i].description);
-         fprintf(f, "key %s = ", cmds[i].name);
-         for(j=0; j<MAX_COMMAND_KEYS; j++)
-           {
-             if( j && cmds[i].keys[j] )
-               fprintf(f, ",  ");
-             if( !j || cmds[i].keys[j] )
-               {
-                 if( cmds[i].keys[j]<256 && (isalpha(cmds[i].keys[j]) || 
-                                             isdigit(cmds[i].keys[j])) )
-                   fprintf(f, "\'%c\'", cmds[i].keys[j]);
-                 else
-                   fprintf(f, "%d", cmds[i].keys[j]);
+       int i,j;
+
+       if( flags & KEYDEF_WRITE_HEADER )
+               fprintf(f, "## Key bindings for ncmpc (generated by ncmpc)\n\n");
+
+       i=0;
+       while (cmds[i].name && !ferror(f)) {
+               if (cmds[i].flags & COMMAND_KEY_MODIFIED ||
+                   flags & KEYDEF_WRITE_ALL) {
+                       fprintf(f, "## %s\n", cmds[i].description);
+                       if (flags & KEYDEF_COMMENT_ALL)
+                               fprintf(f, "#");
+                       fprintf(f, "key %s = ", cmds[i].name);
+                       for (j = 0; j < MAX_COMMAND_KEYS; j++) {
+                               if (j && cmds[i].keys[j])
+                                       fprintf(f, ",  ");
+                               if (!j || cmds[i].keys[j]) {
+                                       if (cmds[i].keys[j]<256 && (isalpha(cmds[i].keys[j]) ||
+                                                                   isdigit(cmds[i].keys[j])))
+                                               fprintf(f, "\'%c\'", cmds[i].keys[j]);
+                                       else
+                                               fprintf(f, "%d", cmds[i].keys[j]);
+                               }
+                       }
+                       fprintf(f,"\n\n");
                }
-           }
-         fprintf(f,"\n\n");
+               i++;
        }
-      i++;
-    }
-  return ferror(f);
+
+       return ferror(f);
 }