/[weechat]/weechat/src/gui/gui-common.c
ViewVC logotype

Diff of /weechat/src/gui/gui-common.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.58 by flashcode, Sat Oct 22 14:04:27 2005 UTC revision 1.59 by flashcode, Sun Oct 30 09:56:25 2005 UTC
# Line 17  Line 17 
17   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18   */   */
19    
20  /* gui-common.c: display functions, used by any GUI */  /* gui-common.c: display functions, used by all GUI */
21    
22    
23  #ifdef HAVE_CONFIG_H  #ifdef HAVE_CONFIG_H
# Line 58  t_gui_buffer *last_gui_buffer = NULL; Line 58  t_gui_buffer *last_gui_buffer = NULL;
58  t_gui_buffer *buffer_before_dcc = NULL;     /* buffer before dcc switch     */  t_gui_buffer *buffer_before_dcc = NULL;     /* buffer before dcc switch     */
59  t_gui_infobar *gui_infobar;                 /* pointer to infobar content   */  t_gui_infobar *gui_infobar;                 /* pointer to infobar content   */
60    
61  char *gui_input_clipboard = NULL;           /* buffer to store clipboard content */  char *gui_input_clipboard = NULL;           /* clipboard content            */
62    
63  /*  /*
64   * gui_window_new: create a new window   * gui_window_new: create a new window
# Line 135  gui_window_new (int x, int y, int width, Line 135  gui_window_new (int x, int y, int width,
135  }  }
136    
137  /*  /*
138     * gui_buffer_servers_search: search servers buffer
139     *                            (when same buffer is used for all servers)
140     */
141    
142    t_gui_buffer *
143    gui_buffer_servers_search ()
144    {
145        t_gui_buffer *ptr_buffer;
146        
147        for (ptr_buffer = gui_buffers; ptr_buffer;
148             ptr_buffer = ptr_buffer->next_buffer)
149        {
150            if (ptr_buffer->all_servers)
151                return ptr_buffer;
152        }
153        
154        /* buffer not found */
155        return NULL;
156    }
157    
158    /*
159   * gui_buffer_new: create a new buffer in current window   * gui_buffer_new: create a new buffer in current window
160   */   */
161    
# Line 142  t_gui_buffer * Line 163  t_gui_buffer *
163  gui_buffer_new (t_gui_window *window, void *server, void *channel, int dcc,  gui_buffer_new (t_gui_window *window, void *server, void *channel, int dcc,
164                  int switch_to_buffer)                  int switch_to_buffer)
165  {  {
166      t_gui_buffer *new_buffer;      t_gui_buffer *new_buffer, *ptr_buffer;
167            
168      #ifdef DEBUG      #ifdef DEBUG
169      wee_log_printf ("Creating new buffer\n");      wee_log_printf ("Creating new buffer\n");
# Line 157  gui_buffer_new (t_gui_window *window, vo Line 178  gui_buffer_new (t_gui_window *window, vo
178              ((t_irc_channel *)(channel))->buffer = gui_buffers;              ((t_irc_channel *)(channel))->buffer = gui_buffers;
179          gui_buffers->server = server;          gui_buffers->server = server;
180          gui_buffers->channel = channel;          gui_buffers->channel = channel;
181            if (cfg_look_one_server_buffer && server && !channel)
182                gui_buffers->all_servers = 1;
183          if (cfg_log_auto_server)          if (cfg_log_auto_server)
184              log_start (gui_buffers);              log_start (gui_buffers);
185          return gui_buffers;          return gui_buffers;
186      }      }
187            
188        if (cfg_look_one_server_buffer && !dcc && gui_buffers && server && !channel)
189        {
190            ptr_buffer = gui_buffer_servers_search ();
191            if (ptr_buffer)
192            {
193                ((t_irc_server *)(server))->buffer = gui_buffers;
194                gui_buffers->server = server;
195                if (switch_to_buffer)
196                    gui_switch_to_buffer (window, gui_buffers);
197                gui_redraw_buffer (gui_buffers);
198                return gui_buffers;
199            }
200        }
201        
202      if ((new_buffer = (t_gui_buffer *)(malloc (sizeof (t_gui_buffer)))))      if ((new_buffer = (t_gui_buffer *)(malloc (sizeof (t_gui_buffer)))))
203      {      {
204          new_buffer->num_displayed = 0;          new_buffer->num_displayed = 0;
# Line 169  gui_buffer_new (t_gui_window *window, vo Line 206  gui_buffer_new (t_gui_window *window, vo
206                    
207          /* assign server and channel to buffer */          /* assign server and channel to buffer */
208          new_buffer->server = server;          new_buffer->server = server;
209            new_buffer->all_servers = 0;
210          new_buffer->channel = channel;          new_buffer->channel = channel;
211          new_buffer->dcc = dcc;          new_buffer->dcc = dcc;
212          /* assign buffer to server and channel */          /* assign buffer to server and channel */
213          if (server && !channel)          if (server && !channel)
214            {
215              SERVER(new_buffer)->buffer = new_buffer;              SERVER(new_buffer)->buffer = new_buffer;
216                new_buffer->all_servers = (cfg_look_one_server_buffer) ? 1 : 0;
217            }
218            if (!gui_buffers && cfg_look_one_server_buffer)
219                new_buffer->all_servers = 1;
220          if (channel)          if (channel)
221              CHANNEL(new_buffer)->buffer = new_buffer;              CHANNEL(new_buffer)->buffer = new_buffer;
222                    
# Line 586  gui_new_message (t_gui_buffer *buffer) Line 629  gui_new_message (t_gui_buffer *buffer)
629  }  }
630    
631  /*  /*
632   * gui_input_optimize_buffer_size: optimize input buffer size by adding   * gui_optimize_input_buffer_size: optimize input buffer size by adding
633   *                                 or deleting data block (predefined size)   *                                 or deleting data block (predefined size)
634   */   */
635    
636  void  void
637  gui_input_optimize_buffer_size (t_gui_buffer *buffer)  gui_optimize_input_buffer_size (t_gui_buffer *buffer)
638  {  {
639      int optimal_size;      int optimal_size;
640            
# Line 608  gui_input_optimize_buffer_size (t_gui_bu Line 651  gui_input_optimize_buffer_size (t_gui_bu
651  }  }
652    
653  /*  /*
654   * gui_input_action_dcc: execute an action on a DCC after a user input   * gui_exec_action_dcc: execute an action on a DCC after a user input
655   *                       return -1 if DCC buffer was closed due to action, 0 otherwise   *                      return -1 if DCC buffer was closed due to action, 0 otherwise
656   */   */
657    
658  void  void
659  gui_input_action_dcc (t_gui_window *window, char *actions)  gui_exec_action_dcc (t_gui_window *window, char *actions)
660  {  {
661      t_irc_dcc *dcc_selected, *ptr_dcc, *ptr_dcc_next;      t_irc_dcc *dcc_selected, *ptr_dcc, *ptr_dcc_next;
662      t_gui_buffer *ptr_buffer;      t_gui_buffer *ptr_buffer;
# Line 696  gui_input_action_dcc (t_gui_window *wind Line 739  gui_input_action_dcc (t_gui_window *wind
739  }  }
740    
741  /*  /*
742   * gui_input_insert_string: insert a string into the input buffer   * gui_insert_string_input: insert a string into the input buffer
743   *                          if pos == -1, string is inserted at cursor position   *                          if pos == -1, string is inserted at cursor position
744   *                          return: number of chars inserted   *                          return: number of chars inserted
745   *                          (may be different of strlen if UTF-8 string)   *                          (may be different of strlen if UTF-8 string)
746   */   */
747    
748  int  int
749  gui_input_insert_string (t_gui_window *window, char *string, int pos)  gui_insert_string_input (t_gui_window *window, char *string, int pos)
750  {  {
751      int size, length;      int size, length;
752      char *ptr_start;      char *ptr_start;
# Line 719  gui_input_insert_string (t_gui_window *w Line 762  gui_input_insert_string (t_gui_window *w
762          /* increase buffer size */          /* increase buffer size */
763          window->buffer->input_buffer_size += size;          window->buffer->input_buffer_size += size;
764          window->buffer->input_buffer_length += length;          window->buffer->input_buffer_length += length;
765          gui_input_optimize_buffer_size (window->buffer);          gui_optimize_input_buffer_size (window->buffer);
766          window->buffer->input_buffer[window->buffer->input_buffer_size] = '\0';          window->buffer->input_buffer[window->buffer->input_buffer_size] = '\0';
767                    
768          /* move end of string to the right */          /* move end of string to the right */
# Line 734  gui_input_insert_string (t_gui_window *w Line 777  gui_input_insert_string (t_gui_window *w
777  }  }
778    
779  /*  /*
780   * gui_input_clipboard_copy: copy string into clipboard   * gui_merge_servers: merge server buffers in one buffer
781   */   */
782    
783  void  void
784  gui_input_clipboard_copy (char *buffer, int size)  gui_merge_servers (t_gui_window *window)
785  {  {
786      if (size <= 0)      t_gui_buffer *ptr_buffer_server, *ptr_buffer;
787          return;      t_irc_server *ptr_server;
       
     if (gui_input_clipboard != NULL)  
         free (gui_input_clipboard);  
       
     gui_input_clipboard = (char *) malloc( (size + 1) * sizeof(*gui_input_clipboard));  
       
     if (gui_input_clipboard)  
     {  
         memcpy (gui_input_clipboard, buffer, size);  
         gui_input_clipboard[size] = '\0';  
     }  
 }  
   
 /*  
  * gui_input_clipboard_paste: paste clipboard at cursor pos in input line  
  */  
   
 void  
 gui_input_clipboard_paste (t_gui_window *window)  
 {  
     if (window->buffer->has_input && gui_input_clipboard)  
     {  
         gui_input_insert_string (window, gui_input_clipboard, -1);  
         window->buffer->input_buffer_pos += utf8_strlen (gui_input_clipboard);  
         gui_draw_buffer_input (window->buffer, 0);  
         window->buffer->completion.position = -1;  
     }  
 }  
   
 /*  
  * gui_input_return: terminate line (return pressed)  
  */  
   
 void  
 gui_input_return (t_gui_window *window)  
 {  
     t_gui_buffer *ptr_buffer;  
788            
789      if (window->buffer->has_input)      /* new server buffer is the first server buffer found */
790      {      for (ptr_buffer_server = gui_buffers; ptr_buffer_server;
791          if (window->buffer->input_buffer_size > 0)           ptr_buffer_server = ptr_buffer_server->next_buffer)
         {  
             window->buffer->input_buffer[window->buffer->input_buffer_size] = '\0';  
             history_add (window->buffer, window->buffer->input_buffer);  
             window->buffer->input_buffer_size = 0;  
             window->buffer->input_buffer_length = 0;  
             window->buffer->input_buffer_pos = 0;  
             window->buffer->input_buffer_1st_display = 0;  
             window->buffer->completion.position = -1;  
             window->buffer->ptr_history = NULL;  
             ptr_buffer = window->buffer;  
             user_command (SERVER(window->buffer),  
                           window->buffer,  
                           window->buffer->input_buffer);  
             if (ptr_buffer == window->buffer)  
             {  
                 ptr_buffer->input_buffer[0] = '\0';  
                 gui_draw_buffer_input (ptr_buffer, 0);  
             }  
         }  
     }  
 }  
   
 /*  
  * gui_input_tab: tab key => completion  
  */  
   
 void  
 gui_input_tab (t_gui_window *window)  
 {  
     int i;  
   
     if (window->buffer->has_input)  
792      {      {
793          completion_search (&(window->buffer->completion),          if (BUFFER_IS_SERVER(ptr_buffer_server))
794                             CHANNEL(window->buffer),              break;
                            window->buffer->input_buffer,  
                            window->buffer->input_buffer_size,  
                            utf8_real_pos (window->buffer->input_buffer,  
                                           window->buffer->input_buffer_pos));  
           
         if (window->buffer->completion.word_found)  
         {  
             /* replace word with new completed word into input buffer */  
             if (window->buffer->completion.diff_size > 0)  
             {  
                 window->buffer->input_buffer_size +=  
                     window->buffer->completion.diff_size;  
                 window->buffer->input_buffer_length +=  
                     window->buffer->completion.diff_length;  
                 gui_input_optimize_buffer_size (window->buffer);  
                 window->buffer->input_buffer[window->buffer->input_buffer_size] = '\0';  
                 for (i = window->buffer->input_buffer_size - 1;  
                      i >=  window->buffer->completion.position_replace +  
                          (int)strlen (window->buffer->completion.word_found); i--)  
                     window->buffer->input_buffer[i] =  
                         window->buffer->input_buffer[i - window->buffer->completion.diff_size];  
             }  
             else  
             {  
                 for (i = window->buffer->completion.position_replace +  
                          strlen (window->buffer->completion.word_found);  
                      i < window->buffer->input_buffer_size; i++)  
                     window->buffer->input_buffer[i] =  
                         window->buffer->input_buffer[i - window->buffer->completion.diff_size];  
                 window->buffer->input_buffer_size +=  
                     window->buffer->completion.diff_size;  
                 window->buffer->input_buffer_length +=  
                     window->buffer->completion.diff_length;  
                 gui_input_optimize_buffer_size (window->buffer);  
                 window->buffer->input_buffer[window->buffer->input_buffer_size] = '\0';  
             }  
               
             strncpy (window->buffer->input_buffer + window->buffer->completion.position_replace,  
                      window->buffer->completion.word_found,  
                      strlen (window->buffer->completion.word_found));  
             window->buffer->input_buffer_pos =  
                 utf8_pos (window->buffer->input_buffer,  
                           window->buffer->completion.position_replace) +  
                 utf8_strlen (window->buffer->completion.word_found);  
                           
             /* position is < 0 this means only one word was found to complete,  
                so reinit to stop completion */  
             if (window->buffer->completion.position >= 0)  
                 window->buffer->completion.position =  
                     utf8_real_pos (window->buffer->input_buffer,  
                                    window->buffer->input_buffer_pos);  
                           
             /* add space or completor to the end of completion, if needed */  
             if ((window->buffer->completion.context == COMPLETION_COMMAND)  
                 || (window->buffer->completion.context == COMPLETION_COMMAND_ARG))  
             {  
                 if (window->buffer->input_buffer[utf8_real_pos (window->buffer->input_buffer,  
                                                                 window->buffer->input_buffer_pos)] != ' ')  
                     gui_input_insert_string (window, " ",  
                                              window->buffer->input_buffer_pos);  
                 if (window->buffer->completion.position >= 0)  
                     window->buffer->completion.position++;  
                 window->buffer->input_buffer_pos++;  
             }  
             else  
             {  
                 /* add nick completor if position 0 and completing nick */  
                 if ((window->buffer->completion.base_word_pos == 0)  
                     && (window->buffer->completion.context == COMPLETION_NICK))  
                 {  
                     if (strncmp (utf8_add_offset (window->buffer->input_buffer,  
                                                   window->buffer->input_buffer_pos),  
                                  cfg_look_completor, strlen (cfg_look_completor)) != 0)  
                         gui_input_insert_string (window, cfg_look_completor,  
                                                  window->buffer->input_buffer_pos);  
                     if (window->buffer->completion.position >= 0)  
                         window->buffer->completion.position += strlen (cfg_look_completor);  
                     window->buffer->input_buffer_pos += utf8_strlen (cfg_look_completor);  
                     if (window->buffer->input_buffer[utf8_real_pos (window->buffer->input_buffer,  
                                                                     window->buffer->input_buffer_pos)] != ' ')  
                         gui_input_insert_string (window, " ",  
                                                  window->buffer->input_buffer_pos);  
                     if (window->buffer->completion.position >= 0)  
                         window->buffer->completion.position++;  
                     window->buffer->input_buffer_pos++;  
                 }  
             }  
             gui_draw_buffer_input (window->buffer, 0);  
         }  
     }  
 }  
   
 /*  
  * gui_input_backspace: backspace key  
  */  
   
 void  
 gui_input_backspace (t_gui_window *window)  
 {  
     char *pos, *pos_last;  
     int char_size, size_to_move;  
   
     if (window->buffer->has_input)  
     {  
         if (window->buffer->input_buffer_pos > 0)  
         {  
             pos = utf8_add_offset (window->buffer->input_buffer,  
                                    window->buffer->input_buffer_pos);  
             pos_last = utf8_prev_char (window->buffer->input_buffer, pos);  
             char_size = pos - pos_last;  
             size_to_move = strlen (pos);  
             memmove (pos_last, pos, size_to_move);  
             window->buffer->input_buffer_size -= char_size;  
             window->buffer->input_buffer_length--;  
             window->buffer->input_buffer_pos--;  
             window->buffer->input_buffer[window->buffer->input_buffer_size] = '\0';  
             gui_input_optimize_buffer_size (window->buffer);  
             gui_draw_buffer_input (window->buffer, 0);  
             window->buffer->completion.position = -1;  
         }  
795      }      }
 }  
   
 /*  
  * gui_input_delete: delete key  
  */  
   
 void  
 gui_input_delete (t_gui_window *window)  
 {  
     char *pos, *pos_next;  
     int char_size, size_to_move;  
796            
797      if (window->buffer->has_input)      /* no server buffer found */
798      {      if (!ptr_buffer_server)
799          if (window->buffer->input_buffer_pos <          return;
             window->buffer->input_buffer_length)  
         {  
             pos = utf8_add_offset (window->buffer->input_buffer,  
                                    window->buffer->input_buffer_pos);  
             pos_next = utf8_next_char (pos);  
             char_size = pos_next - pos;  
             size_to_move = strlen (pos_next);  
             memmove (pos, pos_next, size_to_move);  
             window->buffer->input_buffer_size -= char_size;  
             window->buffer->input_buffer_length--;  
             window->buffer->input_buffer[window->buffer->input_buffer_size] = '\0';  
             gui_input_optimize_buffer_size (window->buffer);  
             gui_draw_buffer_input (window->buffer, 0);  
             window->buffer->completion.position = -1;  
         }  
     }  
 }  
   
 /*  
  * gui_input_delete_previous_word: delete previous word  
  */  
   
 void  
 gui_input_delete_previous_word (t_gui_window *window)  
 {  
     int length_deleted, size_deleted;  
     char *start, *string;  
800            
801      if (window->buffer->has_input)      for (ptr_buffer = gui_buffers; ptr_buffer;
802             ptr_buffer = ptr_buffer->next_buffer)
803      {      {
804          if (window->buffer->input_buffer_pos > 0)          if ((ptr_buffer != ptr_buffer_server)
805                && (BUFFER_IS_SERVER(ptr_buffer)))
806          {          {
807              start = utf8_add_offset (window->buffer->input_buffer,              ptr_server = SERVER(ptr_buffer);
808                                        window->buffer->input_buffer_pos - 1);              
809              string = start;              /* add (by pointer artefact) lines from buffer found to server buffer */
810              while (string && (string[0] == ' '))              if (ptr_buffer->lines)
             {  
                 string = utf8_prev_char (window->buffer->input_buffer, string);  
             }  
             if (string)  
811              {              {
812                  while (string && (string[0] != ' '))                  if (ptr_buffer_server->lines)
813                  {                  {
814                      string = utf8_prev_char (window->buffer->input_buffer, string);                      ptr_buffer->lines->prev_line =
815                            ptr_buffer_server->last_line;
816                        ptr_buffer_server->last_line->next_line =
817                            ptr_buffer->lines;
818                        ptr_buffer_server->last_line =
819                            ptr_buffer->last_line;
820                  }                  }
821                  if (string)                  else
822                  {                  {
823                      while (string && (string[0] == ' '))                      ptr_buffer_server->lines = ptr_buffer->lines;
824                      {                      ptr_buffer_server->last_line = ptr_buffer->last_line;
                         string = utf8_prev_char (window->buffer->input_buffer, string);  
                     }  
825                  }                  }
826              }              }
827                            
828              if (string)              /* free buffer but not lines, because they're now used by
829                  string = utf8_next_char (utf8_next_char (string));                 our unique server buffer */
830              else              ptr_buffer->lines = NULL;
831                  string = window->buffer->input_buffer;              gui_buffer_free (ptr_buffer, 1);
               
             size_deleted = utf8_next_char (start) - string;  
             length_deleted = utf8_strnlen (string, size_deleted);  
832                            
833              gui_input_clipboard_copy (string, size_deleted);              /* asociate server with new server buffer */
834                            ptr_server->buffer = ptr_buffer_server;
             memmove (string, string + size_deleted, size_deleted);  
               
             window->buffer->input_buffer_size -= size_deleted;  
             window->buffer->input_buffer_length -= length_deleted;  
             window->buffer->input_buffer[window->buffer->input_buffer_size] = '\0';  
             window->buffer->input_buffer_pos -= length_deleted;  
             gui_input_optimize_buffer_size (window->buffer);  
             gui_draw_buffer_input (window->buffer, 0);  
             window->buffer->completion.position = -1;  
835          }          }
836      }      }
 }  
   
 /*  
  * gui_input_delete_next_word: delete next word  
  */  
   
 void  
 gui_input_delete_next_word (t_gui_window *window)  
 {  
     int size_deleted, length_deleted;  
     char *start, *string;  
837            
838      if (window->buffer->has_input)      ptr_buffer_server->all_servers = 1;
839      {      gui_redraw_buffer (window->buffer);
         start = utf8_add_offset (window->buffer->input_buffer,  
                                  window->buffer->input_buffer_pos);  
         string = start;  
         length_deleted = 0;  
         while (string[0])  
         {  
             if ((string[0] == ' ') && (string > start))  
                 break;  
             string = utf8_next_char (string);  
             length_deleted++;  
         }  
         size_deleted = string - start;  
           
         gui_input_clipboard_copy(start, size_deleted);  
           
         memmove (start, string, strlen (string));  
           
         window->buffer->input_buffer_size -= size_deleted;  
         window->buffer->input_buffer_length -= length_deleted;  
         window->buffer->input_buffer[window->buffer->input_buffer_size] = '\0';  
         gui_input_optimize_buffer_size (window->buffer);  
         gui_draw_buffer_input (window->buffer, 0);  
         window->buffer->completion.position = -1;  
     }  
840  }  }
841    
842  /*  /*
843   * gui_input_delete_begin_of_line: delete all from cursor pos to beginning of line   * gui_split_server: split the server buffer into many buffers (one by server)
844   */   */
845    
846  void  void
847  gui_input_delete_begin_of_line (t_gui_window *window)  gui_split_server (t_gui_window *window)
848  {  {
849      int length_deleted, size_deleted;      t_gui_buffer *ptr_buffer;
850      char *start;      t_irc_server *ptr_server;
851            
852      if (window->buffer->has_input)      ptr_buffer = gui_buffer_servers_search ();
     {  
         if (window->buffer->input_buffer_pos > 0)  
         {  
             start = utf8_add_offset (window->buffer->input_buffer,  
                                      window->buffer->input_buffer_pos);  
             size_deleted = start - window->buffer->input_buffer;  
             length_deleted = utf8_strnlen (window->buffer->input_buffer, size_deleted);  
             gui_input_clipboard_copy (window->buffer->input_buffer,  
                                       start - window->buffer->input_buffer);  
               
             memmove (window->buffer->input_buffer, start, strlen (start));  
               
             window->buffer->input_buffer_size -= size_deleted;  
             window->buffer->input_buffer_length -= length_deleted;  
             window->buffer->input_buffer[window->buffer->input_buffer_size] = '\0';  
             window->buffer->input_buffer_pos = 0;  
             gui_input_optimize_buffer_size (window->buffer);  
             gui_draw_buffer_input (window->buffer, 0);  
             window->buffer->completion.position = -1;  
         }  
     }  
 }  
   
 /*  
  * gui_input_delete_end_of_line: delete all from cursor pos to end of line  
  */  
   
 void  
 gui_input_delete_end_of_line (t_gui_window *window)  
 {  
     char *start;  
     int size_deleted, length_deleted;  
853            
854      if (window->buffer->has_input)      if (ptr_buffer)
     {  
         start = utf8_add_offset (window->buffer->input_buffer,  
                                  window->buffer->input_buffer_pos);  
         size_deleted = strlen (start);  
         length_deleted = utf8_strlen (start);  
         gui_input_clipboard_copy(start, size_deleted);  
         start[0] = '\0';  
         window->buffer->input_buffer_size = strlen (window->buffer->input_buffer);  
         window->buffer->input_buffer_length = utf8_strlen (window->buffer->input_buffer);  
         gui_input_optimize_buffer_size (window->buffer);  
         gui_draw_buffer_input (window->buffer, 0);  
         window->buffer->completion.position = -1;  
     }  
 }  
   
 /*  
  * gui_input_delete_line: delete entire line  
  */  
   
 void  
 gui_input_delete_line (t_gui_window *window)  
 {  
     if (window->buffer->has_input)  
     {  
         window->buffer->input_buffer[0] = '\0';  
         window->buffer->input_buffer_size = 0;  
         window->buffer->input_buffer_length = 0;  
         window->buffer->input_buffer_pos = 0;  
         gui_input_optimize_buffer_size (window->buffer);  
         gui_draw_buffer_input (window->buffer, 0);  
         window->buffer->completion.position = -1;  
     }  
 }  
   
 /*  
  * gui_input_transpose_chars: transpose chars (on lth left) at cursor pos  
  */  
   
 void  
 gui_input_transpose_chars (t_gui_window *window)  
 {  
     char *start, *prev_char, saved_char[4];  
     int size_current_char;  
       
     if (window->buffer->has_input)  
     {  
         if (window->buffer->input_buffer_pos > 0)  
         {  
             if (window->buffer->input_buffer_pos == window->buffer->input_buffer_length)  
                 window->buffer->input_buffer_pos--;  
               
             start = utf8_add_offset (window->buffer->input_buffer,  
                                      window->buffer->input_buffer_pos);  
             prev_char = utf8_prev_char (window->buffer->input_buffer,  
                                         start);  
             size_current_char = start - prev_char;  
             memcpy (saved_char, prev_char, size_current_char);  
             memcpy (prev_char, start, utf8_char_size (start));  
             start = utf8_next_char (prev_char);  
             memcpy (start, saved_char, size_current_char);  
               
             window->buffer->input_buffer_pos++;  
               
             gui_draw_buffer_input (window->buffer, 0);    
             window->buffer->completion.position = -1;  
         }  
     }  
 }  
   
 /*  
  * gui_input_home: home key  
  */  
   
 void  
 gui_input_home (t_gui_window *window)  
 {  
     if (window->buffer->has_input)  
     {  
         if (window->buffer->input_buffer_pos > 0)  
         {  
             window->buffer->input_buffer_pos = 0;  
             gui_draw_buffer_input (window->buffer, 0);  
         }  
     }  
 }  
   
 /*  
  * gui_input_end: end key  
  */  
   
 void  
 gui_input_end (t_gui_window *window)  
 {  
     if (window->buffer->has_input)  
     {  
         if (window->buffer->input_buffer_pos <  
             window->buffer->input_buffer_length)  
         {  
             window->buffer->input_buffer_pos =  
                 window->buffer->input_buffer_length;  
             gui_draw_buffer_input (window->buffer, 0);  
         }  
     }  
 }  
   
 /*  
  * gui_input_left: move to previous char  
  */  
   
 void  
 gui_input_left (t_gui_window *window)  
 {  
     if (window->buffer->has_input)  
     {  
         if (window->buffer->input_buffer_pos > 0)  
         {  
             window->buffer->input_buffer_pos--;  
             gui_draw_buffer_input (window->buffer, 0);  
         }  
     }  
 }  
   
 /*  
  * gui_input_previous_word: move to beginning of previous word  
  */  
   
 void  
 gui_input_previous_word (t_gui_window *window)  
 {  
     char *pos;  
       
     if (window->buffer->has_input)  
855      {      {
856          if (window->buffer->input_buffer_pos > 0)          if (SERVER(ptr_buffer))
857          {          {
858              pos = utf8_add_offset (window->buffer->input_buffer,              for (ptr_server = irc_servers; ptr_server;
859                                     window->buffer->input_buffer_pos - 1);                   ptr_server = ptr_server->next_server)
             while (pos && (pos[0] == ' '))  
             {  
                 pos = utf8_prev_char (window->buffer->input_buffer, pos);  
             }  
             if (pos)  
860              {              {
861                  while (pos && (pos[0] != ' '))                  if (ptr_server->buffer
862                        && (ptr_server != SERVER(ptr_buffer))
863                        && (ptr_server->buffer == ptr_buffer))
864                  {                  {
865                      pos = utf8_prev_char (window->buffer->input_buffer, pos);                      ptr_server->buffer = NULL;
866                        gui_buffer_new (window, ptr_server, NULL, 0, 0);
867                  }                  }
                 if (pos)  
                     pos = utf8_next_char (pos);  
                 else  
                     pos = window->buffer->input_buffer;  
                 window->buffer->input_buffer_pos = utf8_pos (window->buffer->input_buffer,  
                                                              pos - window->buffer->input_buffer);  
868              }              }
             else  
                 window->buffer->input_buffer_pos = 0;  
               
             gui_draw_buffer_input (window->buffer, 0);  
869          }          }
870            ptr_buffer->all_servers = 0;
871            gui_draw_buffer_status (window->buffer, 1);
872            gui_draw_buffer_input (window->buffer, 1);
873      }      }
874  }  }
875    
876  /*  /*
877   * gui_input_right: move to previous char   * gui_window_switch_server: switch server on servers buffer
878     *                           (if same buffer is used for all buffers)
879   */   */
880    
881  void  void
882  gui_input_right (t_gui_window *window)  gui_window_switch_server (t_gui_window *window)
883  {  {
884      if (window->buffer->has_input)      t_gui_buffer *ptr_buffer;
885      {      t_irc_server *ptr_server;
         if (window->buffer->input_buffer_pos <  
             window->buffer->input_buffer_length)  
         {  
             window->buffer->input_buffer_pos++;  
             gui_draw_buffer_input (window->buffer, 0);  
         }  
     }  
 }  
   
 /*  
  * gui_input_next_word: move to the end of next  
  */  
   
 void  
 gui_input_next_word (t_gui_window *window)  
 {  
     char *pos;  
886            
887      if (window->buffer->has_input)      ptr_buffer = gui_buffer_servers_search ();
888        
889        if (ptr_buffer)
890      {      {
891          if (window->buffer->input_buffer_pos <          ptr_server = (SERVER(ptr_buffer)) ?
892              window->buffer->input_buffer_length)              SERVER(ptr_buffer)->next_server : irc_servers;
893            while (ptr_server != SERVER(window->buffer))
894          {          {
895              pos = utf8_add_offset (window->buffer->input_buffer,              if (ptr_server->buffer)
896                                     window->buffer->input_buffer_pos);                  break;
897              while (pos[0] && (pos[0] == ' '))              if (ptr_server->next_server)
898              {                  ptr_server = ptr_server->next_server;
                 pos = utf8_next_char (pos);  
             }  
             if (pos[0])  
             {  
                 while (pos[0] && (pos[0] != ' '))  
                 {  
                     pos = utf8_next_char (pos);  
                 }  
                 if (pos[0])  
                     window->buffer->input_buffer_pos =  
                         utf8_pos (window->buffer->input_buffer,  
                                   pos - window->buffer->input_buffer);  
                 else  
                     window->buffer->input_buffer_pos =  
                         window->buffer->input_buffer_length;  
             }  
899              else              else
                 window->buffer->input_buffer_pos =  
                     utf8_pos (window->buffer->input_buffer,  
                               utf8_prev_char (window->buffer->input_buffer, pos) - window->buffer->input_buffer);  
               
             gui_draw_buffer_input (window->buffer, 0);  
         }  
     }  
 }  
   
 /*  
  * gui_input_up: recall last command or move to previous DCC in list  
  */  
   
 void  
 gui_input_up (t_gui_window *window)  
 {  
     if (window->buffer->dcc)  
     {  
         if (dcc_list)  
         {  
             if (window->dcc_selected  
                 && ((t_irc_dcc *)(window->dcc_selected))->prev_dcc)  
             {  
                 if (window->dcc_selected ==  
                     window->dcc_first)  
                     window->dcc_first =  
                         ((t_irc_dcc *)(window->dcc_first))->prev_dcc;  
                 window->dcc_selected =  
                     ((t_irc_dcc *)(window->dcc_selected))->prev_dcc;  
                 gui_draw_buffer_chat (window->buffer, 1);  
                 gui_draw_buffer_input (window->buffer, 1);  
             }  
         }  
     }  
     else if (window->buffer->has_input)  
     {  
         if (window->buffer->ptr_history)  
         {  
             window->buffer->ptr_history =  
                 window->buffer->ptr_history->next_history;  
             if (!window->buffer->ptr_history)  
                 window->buffer->ptr_history =  
                     window->buffer->history;  
         }  
         else  
             window->buffer->ptr_history =  
                 window->buffer->history;  
         if (window->buffer->ptr_history)  
         {  
             window->buffer->input_buffer_size =  
                 strlen (window->buffer->ptr_history->text);  
             window->buffer->input_buffer_length =  
                 utf8_strlen (window->buffer->ptr_history->text);  
             gui_input_optimize_buffer_size (window->buffer);  
             window->buffer->input_buffer_pos =  
                 window->buffer->input_buffer_length;  
             strcpy (window->buffer->input_buffer,  
                     window->buffer->ptr_history->text);  
             gui_draw_buffer_input (window->buffer, 0);  
         }  
     }  
 }  
   
 /*  
  * gui_input_up_global: recall last command in global history  
  */  
   
 void  
 gui_input_up_global (t_gui_window *window)  
 {  
     if (window->buffer->has_input)  
     {  
         if (history_global_ptr)  
         {  
             history_global_ptr = history_global_ptr->next_history;  
             if (!history_global_ptr)  
                 history_global_ptr = history_global;  
         }  
         else  
             history_global_ptr = history_global;  
         if (history_global_ptr)  
         {  
             window->buffer->input_buffer_size =  
                 strlen (history_global_ptr->text);  
             window->buffer->input_buffer_length =  
                 utf8_strlen (history_global_ptr->text);  
             gui_input_optimize_buffer_size (window->buffer);  
             window->buffer->input_buffer_pos =  
                 window->buffer->input_buffer_length;  
             strcpy (window->buffer->input_buffer,  
                     history_global_ptr->text);  
             gui_draw_buffer_input (window->buffer, 0);  
         }  
     }  
 }  
   
 /*  
  * gui_input_down: recall next command or move to next DCC in list  
  */  
   
 void  
 gui_input_down (t_gui_window *window)  
 {  
     if (window->buffer->dcc)  
     {  
         if (dcc_list)  
         {  
             if (!window->dcc_selected  
                 || ((t_irc_dcc *)(window->dcc_selected))->next_dcc)  
900              {              {
901                  if (window->dcc_last_displayed                  if (SERVER(ptr_buffer) == NULL)
                     && (window->dcc_selected ==  
                         window->dcc_last_displayed))  
902                  {                  {
903                      if (window->dcc_first)                      ptr_server = NULL;
904                          window->dcc_first =                      break;
                             ((t_irc_dcc *)(window->dcc_first))->next_dcc;  
                     else  
                         window->dcc_first =  
                             dcc_list->next_dcc;  
905                  }                  }
906                  if (window->dcc_selected)                  ptr_server = irc_servers;
                     window->dcc_selected =  
                         ((t_irc_dcc *)(window->dcc_selected))->next_dcc;  
                 else  
                     window->dcc_selected =  
                         dcc_list->next_dcc;  
                 gui_draw_buffer_chat (window->buffer, 1);  
                 gui_draw_buffer_input (window->buffer, 1);  
             }  
         }  
     }  
     else if (window->buffer->has_input)  
     {  
         if (window->buffer->ptr_history)  
         {  
             window->buffer->ptr_history =  
                 window->buffer->ptr_history->prev_history;  
             if (window->buffer->ptr_history)  
             {  
                 window->buffer->input_buffer_size =  
                     strlen (window->buffer->ptr_history->text);  
                 window->buffer->input_buffer_length =  
                     utf8_strlen (window->buffer->ptr_history->text);  
             }  
             else  
             {  
                 window->buffer->input_buffer_size = 0;  
                 window->buffer->input_buffer_length = 0;  
             }  
             gui_input_optimize_buffer_size (window->buffer);  
             window->buffer->input_buffer_pos =  
                 window->buffer->input_buffer_length;  
             if (window->buffer->ptr_history)  
                 strcpy (window->buffer->input_buffer,  
                         window->buffer->ptr_history->text);  
             gui_draw_buffer_input (window->buffer, 0);  
         }  
     }  
 }  
   
 /*  
  * gui_input_down_global: recall next command in global history  
  */  
   
 void  
 gui_input_down_global (t_gui_window *window)  
 {  
     if (window->buffer->has_input)  
     {  
         if (history_global_ptr)  
         {  
             history_global_ptr = history_global_ptr->prev_history;  
             if (history_global_ptr)  
             {  
                 window->buffer->input_buffer_size =  
                     strlen (history_global_ptr->text);  
                 window->buffer->input_buffer_length =  
                     utf8_strlen (history_global_ptr->text);  
             }  
             else  
             {  
                 window->buffer->input_buffer_size = 0;  
                 window->buffer->input_buffer_length = 0;  
907              }              }
             gui_input_optimize_buffer_size (window->buffer);  
             window->buffer->input_buffer_pos =  
                 window->buffer->input_buffer_length;  
             if (history_global_ptr)  
                 strcpy (window->buffer->input_buffer,  
                         history_global_ptr->text);  
             gui_draw_buffer_input (window->buffer, 0);  
908          }          }
909      }          if (ptr_server && (ptr_server != SERVER(ptr_buffer)))
 }  
   
 /*  
  * gui_input_jump_smart: jump to buffer with activity (alt-A by default)  
  */  
   
 void  
 gui_input_jump_smart (t_gui_window *window)  
 {  
     if (hotlist)  
     {  
         if (!hotlist_initial_buffer)  
             hotlist_initial_buffer = window->buffer;  
         gui_switch_to_buffer (window, hotlist->buffer);  
         gui_redraw_buffer (window->buffer);  
     }  
     else  
     {  
         if (hotlist_initial_buffer)  
910          {          {
911              gui_switch_to_buffer (window, hotlist_initial_buffer);              ptr_buffer->server = ptr_server;
912              gui_redraw_buffer (window->buffer);              gui_draw_buffer_status (window->buffer, 1);
913              hotlist_initial_buffer = NULL;              gui_draw_buffer_input (window->buffer, 1);
914          }          }
915      }      }
916  }  }
917    
918  /*  /*
  * gui_input_jump_dcc: jump to DCC buffer  
  */  
   
 void  
 gui_input_jump_dcc (t_gui_window *window)  
 {  
     if (window->buffer->dcc)  
     {  
         if (buffer_before_dcc)  
         {  
             gui_switch_to_buffer (window,  
                                   buffer_before_dcc);  
             gui_redraw_buffer (window->buffer);  
         }  
     }  
     else  
     {  
         buffer_before_dcc = window->buffer;  
         gui_switch_to_dcc_buffer (window);  
     }  
 }  
   
 /*  
  * gui_input_jump_last_buffer: jump to last buffer  
  */  
   
 void  
 gui_input_jump_last_buffer (t_gui_window *window)  
 {  
     if (last_gui_buffer)  
         gui_switch_to_buffer_by_number (window, last_gui_buffer->number);  
 }  
   
 /*  
  * gui_input_jump_server: jump to server buffer  
  */  
   
 void  
 gui_input_jump_server (t_gui_window *window)  
 {  
     if (SERVER(window->buffer))  
     {  
         if (SERVER(window->buffer)->buffer !=  
             window->buffer)  
         {  
             gui_switch_to_buffer (window,  
                                   SERVER(window->buffer)->buffer);  
             gui_redraw_buffer (window->buffer);  
         }  
     }  
 }  
   
 /*  
  * gui_input_jump_next_server: jump to next server  
  */  
   
 void  
 gui_input_jump_next_server (t_gui_window *window)  
 {  
     t_irc_server *ptr_server;  
     t_gui_buffer *ptr_buffer;  
       
     if (SERVER(window->buffer))  
     {  
         ptr_server = SERVER(window->buffer)->next_server;  
         if (!ptr_server)  
             ptr_server = irc_servers;  
         while (ptr_server != SERVER(window->buffer))  
         {  
             if (ptr_server->buffer)  
                 break;  
             ptr_server = (ptr_server->next_server) ?  
                 ptr_server->next_server : irc_servers;  
         }  
         if (ptr_server != SERVER(window->buffer))  
         {  
             /* save current buffer */  
             SERVER(window->buffer)->buffer->old_channel_buffer =  
                 window->buffer;  
               
             /* come back to memorized chan if found */  
             if (ptr_server->buffer->old_channel_buffer)  
                 ptr_buffer = ptr_server->buffer->old_channel_buffer;  
             else  
                 ptr_buffer = (ptr_server->channels) ?  
                     ptr_server->channels->buffer : ptr_server->buffer;  
             gui_switch_to_buffer (window, ptr_buffer);  
             gui_redraw_buffer (window->buffer);  
         }  
     }  
 }  
   
 /*  
  * gui_input_hotlist_clear: clear hotlist  
  */  
   
 void  
 gui_input_hotlist_clear (t_gui_window *window)  
 {  
     if (hotlist)  
     {  
         hotlist_free_all ();  
         gui_redraw_buffer (window->buffer);  
     }  
     hotlist_initial_buffer = window->buffer;  
 }  
   
 /*  
  * gui_input_infobar_clear: clear infobar  
  */  
   
 void  
 gui_input_infobar_clear (t_gui_window *window)  
 {  
     gui_infobar_remove ();  
     gui_draw_buffer_infobar (window->buffer, 1);  
 }  
   
 /*  
  * gui_input_grab_key: init "grab key mode" (next key will be inserted into input buffer)  
  */  
   
 void  
 gui_input_grab_key (t_gui_window *window)  
 {  
     if (window->buffer->has_input)  
         gui_key_init_grab ();  
 }  
   
 /*  
919   * gui_switch_to_previous_buffer: switch to previous buffer   * gui_switch_to_previous_buffer: switch to previous buffer
920   */   */
921    
# Line 1992  gui_buffer_print_log (t_gui_buffer *buff Line 1227  gui_buffer_print_log (t_gui_buffer *buff
1227      wee_log_printf ("  num_displayed. . . . : %d\n",   buffer->num_displayed);      wee_log_printf ("  num_displayed. . . . : %d\n",   buffer->num_displayed);
1228      wee_log_printf ("  number . . . . . . . : %d\n",   buffer->number);      wee_log_printf ("  number . . . . . . . : %d\n",   buffer->number);
1229      wee_log_printf ("  server . . . . . . . : 0x%X\n", buffer->server);      wee_log_printf ("  server . . . . . . . : 0x%X\n", buffer->server);
1230        wee_log_printf ("  all_servers. . . . . : %d\n",   buffer->all_servers);
1231      wee_log_printf ("  channel. . . . . . . : 0x%X\n", buffer->channel);      wee_log_printf ("  channel. . . . . . . : 0x%X\n", buffer->channel);
1232      wee_log_printf ("  dcc. . . . . . . . . : %d\n",   buffer->dcc);      wee_log_printf ("  dcc. . . . . . . . . : %d\n",   buffer->dcc);
1233      wee_log_printf ("  lines. . . . . . . . : 0x%X\n", buffer->lines);      wee_log_printf ("  lines. . . . . . . . : 0x%X\n", buffer->lines);

Legend:
Removed from v.1.58  
changed lines
  Added in v.1.59

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26