mirror of
https://github.com/moparisthebest/hexchat
synced 2024-11-14 21:35:06 -05:00
449553ffb0
Xtext's transparency barely worked on windows, didn't work on any modern linux wm and used fake transparency. This uses gtk's built in window opacity that works on more systems and is real transparency. Text area only transparency may return with a transition to cairo, if it works on Windows.
1841 lines
45 KiB
C
1841 lines
45 KiB
C
/* X-Chat
|
||
* Copyright (C) 1998 Peter Zelezny.
|
||
*
|
||
* This program is free software; you can redistribute it and/or modify
|
||
* it under the terms of the GNU General Public License as published by
|
||
* the Free Software Foundation; either version 2 of the License, or
|
||
* (at your option) any later version.
|
||
*
|
||
* This program is distributed in the hope that it will be useful,
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
* GNU General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU General Public License
|
||
* along with this program; if not, write to the Free Software
|
||
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
||
*/
|
||
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <sys/types.h>
|
||
#include <sys/stat.h>
|
||
#include <string.h>
|
||
#include <fcntl.h>
|
||
#include <ctype.h>
|
||
|
||
#ifdef WIN32
|
||
#include <io.h>
|
||
#else
|
||
#include <unistd.h>
|
||
#endif
|
||
|
||
#define GLIB_DISABLE_DEPRECATION_WARNINGS
|
||
#include "fe-gtk.h"
|
||
|
||
#include "../common/hexchat.h"
|
||
#include "../common/hexchatc.h"
|
||
#include "../common/cfgfiles.h"
|
||
#include "../common/fe.h"
|
||
#include "../common/userlist.h"
|
||
#include "../common/outbound.h"
|
||
#include "../common/util.h"
|
||
#include "../common/text.h"
|
||
#include "../common/plugin.h"
|
||
#include "../common/typedef.h"
|
||
#include <gdk/gdkkeysyms.h>
|
||
#include "gtkutil.h"
|
||
#include "menu.h"
|
||
#include "xtext.h"
|
||
#include "palette.h"
|
||
#include "maingui.h"
|
||
#include "textgui.h"
|
||
#include "fkeys.h"
|
||
|
||
static void replace_handle (GtkWidget * wid);
|
||
void key_action_tab_clean (void);
|
||
|
||
/***************** Key Binding Code ******************/
|
||
|
||
/* NOTES:
|
||
|
||
To add a new action:
|
||
1) inc KEY_MAX_ACTIONS
|
||
2) write the function at the bottom of this file (with all the others)
|
||
FIXME: Write about calling and returning
|
||
3) Add it to key_actions
|
||
|
||
--AGL
|
||
|
||
*/
|
||
|
||
/* Remember that the *number* of actions is this *plus* 1 --AGL */
|
||
#define KEY_MAX_ACTIONS 14
|
||
|
||
struct key_binding
|
||
{
|
||
int keyval; /* GDK keynumber */
|
||
char *keyname; /* String with the name of the function */
|
||
int action; /* Index into key_actions */
|
||
int mod; /* Flags of STATE_* above */
|
||
char *data1, *data2; /* Pointers to strings, these must be freed */
|
||
struct key_binding *next;
|
||
};
|
||
|
||
struct key_action
|
||
{
|
||
int (*handler) (GtkWidget * wid, GdkEventKey * evt, char *d1, char *d2,
|
||
struct session * sess);
|
||
char *name;
|
||
char *help;
|
||
};
|
||
|
||
struct gcomp_data
|
||
{
|
||
char data[CHANLEN];
|
||
int elen;
|
||
};
|
||
|
||
static int key_load_kbs (char *);
|
||
static void key_load_defaults ();
|
||
static void key_save_kbs (char *);
|
||
static int key_action_handle_command (GtkWidget * wid, GdkEventKey * evt,
|
||
char *d1, char *d2,
|
||
struct session *sess);
|
||
static int key_action_page_switch (GtkWidget * wid, GdkEventKey * evt,
|
||
char *d1, char *d2, struct session *sess);
|
||
int key_action_insert (GtkWidget * wid, GdkEventKey * evt, char *d1, char *d2,
|
||
struct session *sess);
|
||
static int key_action_scroll_page (GtkWidget * wid, GdkEventKey * evt,
|
||
char *d1, char *d2, struct session *sess);
|
||
static int key_action_set_buffer (GtkWidget * wid, GdkEventKey * evt,
|
||
char *d1, char *d2, struct session *sess);
|
||
static int key_action_history_up (GtkWidget * wid, GdkEventKey * evt,
|
||
char *d1, char *d2, struct session *sess);
|
||
static int key_action_history_down (GtkWidget * wid, GdkEventKey * evt,
|
||
char *d1, char *d2, struct session *sess);
|
||
static int key_action_tab_comp (GtkWidget * wid, GdkEventKey * evt, char *d1,
|
||
char *d2, struct session *sess);
|
||
static int key_action_comp_chng (GtkWidget * wid, GdkEventKey * evt, char *d1,
|
||
char *d2, struct session *sess);
|
||
static int key_action_replace (GtkWidget * wid, GdkEventKey * evt, char *d1,
|
||
char *d2, struct session *sess);
|
||
static int key_action_move_tab_left (GtkWidget * wid, GdkEventKey * evt,
|
||
char *d1, char *d2,
|
||
struct session *sess);
|
||
static int key_action_move_tab_right (GtkWidget * wid, GdkEventKey * evt,
|
||
char *d1, char *d2,
|
||
struct session *sess);
|
||
static int key_action_move_tab_family_left (GtkWidget * wid, GdkEventKey * evt,
|
||
char *d1, char *d2,
|
||
struct session *sess);
|
||
static int key_action_move_tab_family_right (GtkWidget * wid, GdkEventKey * evt,
|
||
char *d1, char *d2,
|
||
struct session *sess);
|
||
static int key_action_put_history (GtkWidget * wid, GdkEventKey * evt,
|
||
char *d1, char *d2,
|
||
struct session *sess);
|
||
|
||
static GtkWidget *key_dialog;
|
||
static struct key_binding *keys_root = NULL;
|
||
|
||
static const struct key_action key_actions[KEY_MAX_ACTIONS + 1] = {
|
||
|
||
{key_action_handle_command, "Run Command",
|
||
N_("The \002Run Command\002 action runs the data in Data 1 as if it had been typed into the entry box where you pressed the key sequence. Thus it can contain text (which will be sent to the channel/person), commands or user commands. When run all \002\\n\002 characters in Data 1 are used to deliminate separate commands so it is possible to run more than one command. If you want a \002\\\002 in the actual text run then enter \002\\\\\002")},
|
||
{key_action_page_switch, "Change Page",
|
||
N_("The \002Change Page\002 command switches between pages in the notebook. Set Data 1 to the page you want to switch to. If Data 2 is set to anything then the switch will be relative to the current position. Set Data 1 to auto to switch to the page with the most recent and important activity (queries first, then channels with hilight, channels with dialogue, channels with other data)")},
|
||
{key_action_insert, "Insert in Buffer",
|
||
N_("The \002Insert in Buffer\002 command will insert the contents of Data 1 into the entry where the key sequence was pressed at the current cursor position")},
|
||
{key_action_scroll_page, "Scroll Page",
|
||
N_("The \002Scroll Page\002 command scrolls the text widget up or down one page or one line. Set Data 1 to either Top, Bottom, Up, Down, +1 or -1.")},
|
||
{key_action_set_buffer, "Set Buffer",
|
||
N_("The \002Set Buffer\002 command sets the entry where the key sequence was entered to the contents of Data 1")},
|
||
{key_action_history_up, "Last Command",
|
||
N_("The \002Last Command\002 command sets the entry to contain the last command entered - the same as pressing up in a shell")},
|
||
{key_action_history_down, "Next Command",
|
||
N_("The \002Next Command\002 command sets the entry to contain the next command entered - the same as pressing down in a shell")},
|
||
{key_action_tab_comp, "Complete nick/command",
|
||
N_("This command changes the text in the entry to finish an incomplete nickname or command. If Data 1 is set then double-tabbing in a string will select the last nick, not the next")},
|
||
{key_action_comp_chng, "Change Selected Nick",
|
||
N_("This command scrolls up and down through the list of nicks. If Data 1 is set to anything it will scroll up, else it scrolls down")},
|
||
{key_action_replace, "Check For Replace",
|
||
N_("This command checks the last word entered in the entry against the replace list and replaces it if it finds a match")},
|
||
{key_action_move_tab_left, "Move front tab left",
|
||
N_("This command moves the front tab left by one")},
|
||
{key_action_move_tab_right, "Move front tab right",
|
||
N_("This command moves the front tab right by one")},
|
||
{key_action_move_tab_family_left, "Move tab family left",
|
||
N_("This command moves the current tab family to the left")},
|
||
{key_action_move_tab_family_right, "Move tab family right",
|
||
N_("This command moves the current tab family to the right")},
|
||
{key_action_put_history, "Push input line into history",
|
||
N_("Push input line into history but doesn't send to server")},
|
||
};
|
||
|
||
void
|
||
key_init ()
|
||
{
|
||
keys_root = NULL;
|
||
if (key_load_kbs (NULL) == 1)
|
||
{
|
||
key_load_defaults ();
|
||
if (key_load_kbs (NULL) == 1)
|
||
fe_message (_("There was an error loading key"
|
||
" bindings configuration"), FE_MSG_ERROR);
|
||
}
|
||
}
|
||
|
||
static char *
|
||
key_get_key_name (int keyval)
|
||
{
|
||
return gdk_keyval_name (gdk_keyval_to_lower (keyval));
|
||
}
|
||
|
||
/* Ok, here are the NOTES
|
||
|
||
key_handle_key_press now handles all the key presses and history_keypress is
|
||
now defunct. It goes thru the linked list keys_root and finds a matching
|
||
key. It runs the action func and switches on these values:
|
||
0) Return
|
||
1) Find next
|
||
2) stop signal and return
|
||
|
||
* history_keypress is now dead (and gone)
|
||
* key_handle_key_press now takes its role
|
||
* All the possible actions are in a struct called key_actions (in fkeys.c)
|
||
* it is made of {function, name, desc}
|
||
* key bindings can pass 2 *text* strings to the handler. If more options are nee
|
||
ded a format can be put on one of these options
|
||
* key actions are passed {
|
||
the entry widget
|
||
the Gdk event
|
||
data 1
|
||
data 2
|
||
session struct
|
||
}
|
||
* key bindings are stored in a linked list of key_binding structs
|
||
* which looks like {
|
||
int keyval; GDK keynumber
|
||
char *keyname; String with the name of the function
|
||
int action; Index into key_actions
|
||
int mod; Flags of STATE_* above
|
||
char *data1, *data2; Pointers to strings, these must be freed
|
||
struct key_binding *next;
|
||
}
|
||
* remember that is (data1 || data2) != NULL then they need to be free()'ed
|
||
|
||
--AGL
|
||
|
||
*/
|
||
|
||
gboolean
|
||
key_handle_key_press (GtkWidget *wid, GdkEventKey *evt, session *sess)
|
||
{
|
||
struct key_binding *kb, *last = NULL;
|
||
int keyval = evt->keyval;
|
||
int mod, n;
|
||
GSList *list;
|
||
|
||
/* where did this event come from? */
|
||
list = sess_list;
|
||
while (list)
|
||
{
|
||
sess = list->data;
|
||
if (sess->gui->input_box == wid)
|
||
{
|
||
if (sess->gui->is_tab)
|
||
sess = current_tab;
|
||
break;
|
||
}
|
||
list = list->next;
|
||
}
|
||
if (!list)
|
||
return FALSE;
|
||
current_sess = sess;
|
||
|
||
if (plugin_emit_keypress (sess, evt->state, evt->keyval, evt->length, evt->string))
|
||
return 1;
|
||
|
||
/* maybe the plugin closed this tab? */
|
||
if (!is_session (sess))
|
||
return 1;
|
||
|
||
mod = evt->state & (STATE_CTRL | STATE_ALT | STATE_SHIFT);
|
||
|
||
kb = keys_root;
|
||
while (kb)
|
||
{
|
||
if (kb->keyval == keyval && kb->mod == mod)
|
||
{
|
||
if (kb->action < 0 || kb->action > KEY_MAX_ACTIONS)
|
||
return 0;
|
||
|
||
/* Bump this binding to the top of the list */
|
||
if (last != NULL)
|
||
{
|
||
last->next = kb->next;
|
||
kb->next = keys_root;
|
||
keys_root = kb;
|
||
}
|
||
/* Run the function */
|
||
n = key_actions[kb->action].handler (wid, evt, kb->data1,
|
||
kb->data2, sess);
|
||
switch (n)
|
||
{
|
||
case 0:
|
||
return 1;
|
||
case 2:
|
||
g_signal_stop_emission_by_name (G_OBJECT (wid),
|
||
"key_press_event");
|
||
return 1;
|
||
}
|
||
}
|
||
last = kb;
|
||
kb = kb->next;
|
||
}
|
||
|
||
switch (keyval)
|
||
{
|
||
case GDK_KEY_space:
|
||
key_action_tab_clean ();
|
||
break;
|
||
|
||
#if defined(USE_GTKSPELL)/* && !defined(WIN32) */
|
||
/* gtktextview has no 'activate' event, so we trap ENTER here */
|
||
case GDK_KEY_Return:
|
||
case GDK_KEY_KP_Enter:
|
||
if (!(evt->state & STATE_CTRL))
|
||
{
|
||
g_signal_stop_emission_by_name (G_OBJECT (wid), "key_press_event");
|
||
mg_inputbox_cb (wid, sess->gui);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Walks keys_root and free()'s everything */
|
||
/*static void
|
||
key_free_all ()
|
||
{
|
||
struct key_binding *cur, *next;
|
||
|
||
cur = keys_root;
|
||
while (cur)
|
||
{
|
||
next = cur->next;
|
||
if (cur->data1)
|
||
free (cur->data1);
|
||
if (cur->data2)
|
||
free (cur->data2);
|
||
free (cur);
|
||
cur = next;
|
||
}
|
||
keys_root = NULL;
|
||
}*/
|
||
|
||
/* Turns mod flags into a C-A-S string */
|
||
static char *
|
||
key_make_mod_str (int mod, char *buf)
|
||
{
|
||
int i = 0;
|
||
|
||
if (mod & STATE_CTRL)
|
||
{
|
||
if (i)
|
||
buf[i++] = '-';
|
||
buf[i++] = 'C';
|
||
}
|
||
if (mod & STATE_ALT)
|
||
{
|
||
if (i)
|
||
buf[i++] = '-';
|
||
buf[i++] = 'A';
|
||
}
|
||
if (mod & STATE_SHIFT)
|
||
{
|
||
if (i)
|
||
buf[i++] = '-';
|
||
buf[i++] = 'S';
|
||
}
|
||
buf[i] = 0;
|
||
return buf;
|
||
}
|
||
|
||
/* ***** GUI code here ******************* */
|
||
|
||
/* NOTE: The key_dialog defin is above --AGL */
|
||
static GtkWidget *key_dialog_act_menu, *key_dialog_kb_clist;
|
||
static GtkWidget *key_dialog_tog_c, *key_dialog_tog_s, *key_dialog_tog_a;
|
||
static GtkWidget *key_dialog_ent_key, *key_dialog_ent_d1, *key_dialog_ent_d2;
|
||
static GtkWidget *key_dialog_text;
|
||
|
||
static void
|
||
key_load_defaults ()
|
||
{
|
||
/* This is the default config */
|
||
#define defcfg \
|
||
"C\nPrior\nChange Page\nD1:-1\nD2:Relative\n\n"\
|
||
"C\nNext\nChange Page\nD1:1\nD2:Relative\n\n"\
|
||
"A\n9\nChange Page\nD1:9\nD2!\n\n"\
|
||
"A\n8\nChange Page\nD1:8\nD2!\n\n"\
|
||
"A\n7\nChange Page\nD1:7\nD2!\n\n"\
|
||
"A\n6\nChange Page\nD1:6\nD2!\n\n"\
|
||
"A\n5\nChange Page\nD1:5\nD2!\n\n"\
|
||
"A\n4\nChange Page\nD1:4\nD2!\n\n"\
|
||
"A\n3\nChange Page\nD1:3\nD2!\n\n"\
|
||
"A\n2\nChange Page\nD1:2\nD2!\n\n"\
|
||
"A\n1\nChange Page\nD1:1\nD2!\n\n"\
|
||
"A\ngrave\nChange Page\nD1:auto\nD2!\n\n"\
|
||
"C\no\nInsert in Buffer\nD1:\nD2!\n\n"\
|
||
"C\nb\nInsert in Buffer\nD1:\nD2!\n\n"\
|
||
"C\nk\nInsert in Buffer\nD1:\nD2!\n\n"\
|
||
"S\nNext\nChange Selected Nick\nD1!\nD2!\n\n"\
|
||
"S\nPrior\nChange Selected Nick\nD1:Up\nD2!\n\n"\
|
||
"None\nNext\nScroll Page\nD1:Down\nD2!\n\n"\
|
||
"C\nHome\nScroll Page\nD1:Top\nD2!\n\n"\
|
||
"C\nEnd\nScroll Page\nD1:Bottom\nD2!\n\n"\
|
||
"None\nPrior\nScroll Page\nD1:Up\nD2!\n\n"\
|
||
"S\nDown\nScroll Page\nD1:+1\nD2!\n\n"\
|
||
"S\nUp\nScroll Page\nD1:-1\nD2!\n\n"\
|
||
"None\nDown\nNext Command\nD1!\nD2!\n\n"\
|
||
"None\nUp\nLast Command\nD1!\nD2!\n\n"\
|
||
"None\nTab\nComplete nick/command\nD1!\nD2!\n\n"\
|
||
"None\nspace\nCheck For Replace\nD1!\nD2!\n\n"\
|
||
"None\nReturn\nCheck For Replace\nD1!\nD2!\n\n"\
|
||
"None\nKP_Enter\nCheck For Replace\nD1!\nD2!\n\n"\
|
||
"C\nTab\nComplete nick/command\nD1:Up\nD2!\n\n"\
|
||
"A\nLeft\nMove front tab left\nD1!\nD2!\n\n"\
|
||
"A\nRight\nMove front tab right\nD1!\nD2!\n\n"\
|
||
"CS\nPrior\nMove tab family left\nD1!\nD2!\n\n"\
|
||
"CS\nNext\nMove tab family right\nD1!\nD2!\n\n"\
|
||
"None\nF9\nRun Command\nD1:/GUI MENU TOGGLE\nD2!\n\n"
|
||
int fd;
|
||
|
||
fd = hexchat_open_file ("keybindings.conf", O_CREAT | O_TRUNC | O_WRONLY, 0x180, XOF_DOMODE);
|
||
if (fd < 0)
|
||
/* ???!!! */
|
||
return;
|
||
|
||
write (fd, defcfg, strlen (defcfg));
|
||
close (fd);
|
||
}
|
||
|
||
static void
|
||
key_dialog_close ()
|
||
{
|
||
key_dialog = NULL;
|
||
key_save_kbs (NULL);
|
||
}
|
||
|
||
static void
|
||
key_dialog_add_new (GtkWidget * button, GtkCList * list)
|
||
{
|
||
gchar *strs[] = { "", NULL, NULL, NULL, NULL };
|
||
struct key_binding *kb;
|
||
|
||
strs[1] = _("<none>");
|
||
strs[2] = _("<none>");
|
||
strs[3] = _("<none>");
|
||
strs[4] = _("<none>");
|
||
|
||
kb = malloc (sizeof (struct key_binding));
|
||
|
||
kb->keyval = 0;
|
||
kb->keyname = NULL;
|
||
kb->action = -1;
|
||
kb->mod = 0;
|
||
kb->data1 = kb->data2 = NULL;
|
||
kb->next = keys_root;
|
||
|
||
keys_root = kb;
|
||
|
||
gtk_clist_set_row_data (GTK_CLIST (list),
|
||
gtk_clist_append (GTK_CLIST (list), strs), kb);
|
||
|
||
}
|
||
|
||
static void
|
||
key_dialog_delete (GtkWidget * button, GtkCList * list)
|
||
{
|
||
struct key_binding *kb, *cur, *last;
|
||
int row = gtkutil_clist_selection ((GtkWidget *) list);
|
||
|
||
if (row != -1)
|
||
{
|
||
kb = gtk_clist_get_row_data (list, row);
|
||
cur = keys_root;
|
||
last = NULL;
|
||
while (cur)
|
||
{
|
||
if (cur == kb)
|
||
{
|
||
if (last)
|
||
last->next = kb->next;
|
||
else
|
||
keys_root = kb->next;
|
||
|
||
if (kb->data1)
|
||
free (kb->data1);
|
||
if (kb->data2)
|
||
free (kb->data2);
|
||
free (kb);
|
||
gtk_clist_remove (list, row);
|
||
return;
|
||
}
|
||
last = cur;
|
||
cur = cur->next;
|
||
}
|
||
printf ("*** key_dialog_delete: couldn't find kb in list!\n");
|
||
/*if (getenv ("HEXCHAT_DEBUG"))
|
||
abort ();*/
|
||
}
|
||
}
|
||
|
||
static void
|
||
key_print_text (GtkXText *xtext, char *text)
|
||
{
|
||
unsigned int old = prefs.hex_stamp_text;
|
||
prefs.hex_stamp_text = 0; /* temporarily disable stamps */
|
||
gtk_xtext_clear (GTK_XTEXT (xtext)->buffer, 0);
|
||
PrintTextRaw (GTK_XTEXT (xtext)->buffer, text, 0, 0);
|
||
prefs.hex_stamp_text = old;
|
||
}
|
||
|
||
static void
|
||
key_dialog_sel_act (GtkWidget * un, int num)
|
||
{
|
||
int row = gtkutil_clist_selection (key_dialog_kb_clist);
|
||
struct key_binding *kb;
|
||
|
||
if (row != -1)
|
||
{
|
||
kb = gtk_clist_get_row_data (GTK_CLIST (key_dialog_kb_clist), row);
|
||
kb->action = num;
|
||
gtk_clist_set_text (GTK_CLIST (key_dialog_kb_clist), row, 2,
|
||
_(key_actions[num].name));
|
||
if (key_actions[num].help)
|
||
{
|
||
key_print_text (GTK_XTEXT (key_dialog_text), _(key_actions[num].help));
|
||
}
|
||
}
|
||
}
|
||
|
||
static void
|
||
key_dialog_sel_row (GtkWidget * clist, gint row, gint column,
|
||
GdkEventButton * evt, gpointer data)
|
||
{
|
||
struct key_binding *kb = gtk_clist_get_row_data (GTK_CLIST (clist), row);
|
||
|
||
if (kb == NULL)
|
||
{
|
||
printf ("*** key_dialog_sel_row: kb == NULL\n");
|
||
abort ();
|
||
}
|
||
if (kb->action > -1 && kb->action <= KEY_MAX_ACTIONS)
|
||
{
|
||
gtk_option_menu_set_history (GTK_OPTION_MENU (key_dialog_act_menu),
|
||
kb->action);
|
||
if (key_actions[kb->action].help)
|
||
{
|
||
key_print_text (GTK_XTEXT (key_dialog_text), _(key_actions[kb->action].help));
|
||
}
|
||
}
|
||
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (key_dialog_tog_c),
|
||
(kb->mod & STATE_CTRL) == STATE_CTRL);
|
||
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (key_dialog_tog_s),
|
||
(kb->mod & STATE_SHIFT) == STATE_SHIFT);
|
||
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (key_dialog_tog_a),
|
||
(kb->mod & STATE_ALT) == STATE_ALT);
|
||
|
||
if (kb->data1)
|
||
gtk_entry_set_text (GTK_ENTRY (key_dialog_ent_d1), kb->data1);
|
||
else
|
||
gtk_entry_set_text (GTK_ENTRY (key_dialog_ent_d1), "");
|
||
|
||
if (kb->data2)
|
||
gtk_entry_set_text (GTK_ENTRY (key_dialog_ent_d2), kb->data2);
|
||
else
|
||
gtk_entry_set_text (GTK_ENTRY (key_dialog_ent_d2), "");
|
||
|
||
if (kb->keyname)
|
||
gtk_entry_set_text (GTK_ENTRY (key_dialog_ent_key), kb->keyname);
|
||
else
|
||
gtk_entry_set_text (GTK_ENTRY (key_dialog_ent_key), "");
|
||
}
|
||
|
||
static void
|
||
key_dialog_tog_key (GtkWidget * tog, int kstate)
|
||
{
|
||
int state = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (tog));
|
||
int row = gtkutil_clist_selection (key_dialog_kb_clist);
|
||
struct key_binding *kb;
|
||
char buf[32];
|
||
|
||
if (row == -1)
|
||
return;
|
||
|
||
kb = gtk_clist_get_row_data (GTK_CLIST (key_dialog_kb_clist), row);
|
||
if (state)
|
||
kb->mod |= kstate;
|
||
else
|
||
kb->mod &= ~kstate;
|
||
|
||
gtk_clist_set_text (GTK_CLIST (key_dialog_kb_clist), row, 0,
|
||
key_make_mod_str (kb->mod, buf));
|
||
}
|
||
|
||
static GtkWidget *
|
||
key_dialog_make_toggle (char *label, void *callback, void *option,
|
||
GtkWidget * box)
|
||
{
|
||
GtkWidget *wid;
|
||
|
||
wid = gtk_check_button_new_with_label (label);
|
||
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wid), 0);
|
||
gtk_signal_connect (GTK_OBJECT (wid), "toggled",
|
||
GTK_SIGNAL_FUNC (callback), option);
|
||
gtk_box_pack_end (GTK_BOX (box), wid, 0, 0, 0);
|
||
gtk_widget_show (wid);
|
||
|
||
return wid;
|
||
}
|
||
|
||
static GtkWidget *
|
||
key_dialog_make_entry (char *label, char *act, void *callback, void *option,
|
||
GtkWidget * box)
|
||
{
|
||
GtkWidget *wid, *hbox;;
|
||
|
||
hbox = gtk_hbox_new (0, 2);
|
||
if (label)
|
||
{
|
||
wid = gtk_label_new (label);
|
||
gtk_widget_show (wid);
|
||
gtk_box_pack_start (GTK_BOX (hbox), wid, 0, 0, 0);
|
||
}
|
||
wid = gtk_entry_new ();
|
||
if (act)
|
||
{
|
||
gtk_signal_connect (GTK_OBJECT (wid), act, GTK_SIGNAL_FUNC (callback),
|
||
option);
|
||
}
|
||
gtk_box_pack_start (GTK_BOX (hbox), wid, 0, 0, 0);
|
||
gtk_widget_show (wid);
|
||
gtk_widget_show (hbox);
|
||
|
||
gtk_box_pack_start (GTK_BOX (box), hbox, 0, 0, 0);
|
||
|
||
return wid;
|
||
}
|
||
|
||
static void
|
||
key_dialog_set_key (GtkWidget * entry, GdkEventKey * evt, void *none)
|
||
{
|
||
int row = gtkutil_clist_selection (key_dialog_kb_clist);
|
||
struct key_binding *kb;
|
||
|
||
gtk_entry_set_text (GTK_ENTRY (entry), "");
|
||
|
||
if (row == -1)
|
||
return;
|
||
|
||
kb = gtk_clist_get_row_data (GTK_CLIST (key_dialog_kb_clist), row);
|
||
kb->keyval = evt->keyval;
|
||
kb->keyname = key_get_key_name (kb->keyval);
|
||
gtk_clist_set_text (GTK_CLIST (key_dialog_kb_clist), row, 1, kb->keyname);
|
||
gtk_entry_set_text (GTK_ENTRY (entry), kb->keyname);
|
||
g_signal_stop_emission_by_name (G_OBJECT (entry), "key_press_event");
|
||
}
|
||
|
||
static void
|
||
key_dialog_set_data (GtkWidget * entry, int d)
|
||
{
|
||
const char *text = gtk_entry_get_text (GTK_ENTRY (entry));
|
||
int row = gtkutil_clist_selection (key_dialog_kb_clist);
|
||
struct key_binding *kb;
|
||
char *buf;
|
||
int len = strlen (text);
|
||
|
||
len++;
|
||
|
||
if (row == -1)
|
||
return;
|
||
|
||
kb = gtk_clist_get_row_data (GTK_CLIST (key_dialog_kb_clist), row);
|
||
if (d == 0)
|
||
{ /* using data1 */
|
||
if (kb->data1)
|
||
free (kb->data1);
|
||
buf = (char *) malloc (len);
|
||
memcpy (buf, text, len);
|
||
kb->data1 = buf;
|
||
gtk_clist_set_text (GTK_CLIST (key_dialog_kb_clist), row, 3, text);
|
||
} else
|
||
{
|
||
if (kb->data2)
|
||
free (kb->data2);
|
||
buf = (char *) malloc (len);
|
||
memcpy (buf, text, len);
|
||
kb->data2 = buf;
|
||
gtk_clist_set_text (GTK_CLIST (key_dialog_kb_clist), row, 4, text);
|
||
}
|
||
}
|
||
|
||
void
|
||
key_dialog_show ()
|
||
{
|
||
GtkWidget *vbox, *hbox, *list, *vbox2, *wid, *wid2, *wid3, *hbox2;
|
||
struct key_binding *kb;
|
||
gchar *titles[] = { NULL, NULL, NULL, "1", "2" };
|
||
char temp[32];
|
||
int i;
|
||
|
||
titles[0] = _("Mod");
|
||
titles[1] = _("Key");
|
||
titles[2] = _("Action");
|
||
|
||
if (key_dialog)
|
||
{
|
||
mg_bring_tofront (key_dialog);
|
||
return;
|
||
}
|
||
|
||
key_dialog =
|
||
mg_create_generic_tab ("editkeys", _(DISPLAY_NAME": Keyboard Shortcuts"),
|
||
TRUE, FALSE, key_dialog_close, NULL, 560, 330, &vbox, 0);
|
||
|
||
hbox = gtk_hbox_new (0, 2);
|
||
gtk_box_pack_start (GTK_BOX (vbox), hbox, 1, 1, 0);
|
||
|
||
list = gtkutil_clist_new (5, titles, hbox, 0, key_dialog_sel_row, 0, NULL,
|
||
0, GTK_SELECTION_SINGLE);
|
||
gtk_widget_set_usize (list, 400, 0);
|
||
key_dialog_kb_clist = list;
|
||
|
||
gtk_widget_show (hbox);
|
||
|
||
kb = keys_root;
|
||
|
||
gtk_clist_set_column_width (GTK_CLIST (list), 1, 50);
|
||
gtk_clist_set_column_width (GTK_CLIST (list), 2, 120);
|
||
gtk_clist_set_column_width (GTK_CLIST (list), 3, 50);
|
||
gtk_clist_set_column_width (GTK_CLIST (list), 4, 50);
|
||
|
||
while (kb)
|
||
{
|
||
titles[0] = key_make_mod_str (kb->mod, temp);
|
||
titles[1] = kb->keyname;
|
||
if (kb->action < 0 || kb->action > KEY_MAX_ACTIONS)
|
||
titles[2] = _("<none>");
|
||
else
|
||
titles[2] = key_actions[kb->action].name;
|
||
if (kb->data1)
|
||
titles[3] = kb->data1;
|
||
else
|
||
titles[3] = _("<none>");
|
||
|
||
if (kb->data2)
|
||
titles[4] = kb->data2;
|
||
else
|
||
titles[4] = _("<none>");
|
||
|
||
gtk_clist_set_row_data (GTK_CLIST (list),
|
||
gtk_clist_append (GTK_CLIST (list), titles),
|
||
kb);
|
||
|
||
kb = kb->next;
|
||
}
|
||
|
||
vbox2 = gtk_vbox_new (0, 2);
|
||
gtk_box_pack_end (GTK_BOX (hbox), vbox2, 1, 1, 0);
|
||
wid = gtk_button_new_with_label (_("Add New"));
|
||
gtk_box_pack_start (GTK_BOX (vbox2), wid, 0, 0, 0);
|
||
gtk_signal_connect (GTK_OBJECT (wid), "clicked",
|
||
GTK_SIGNAL_FUNC (key_dialog_add_new), list);
|
||
gtk_widget_show (wid);
|
||
wid = gtk_button_new_with_label (_("Delete"));
|
||
gtk_box_pack_start (GTK_BOX (vbox2), wid, 0, 0, 0);
|
||
gtk_signal_connect (GTK_OBJECT (wid), "clicked",
|
||
GTK_SIGNAL_FUNC (key_dialog_delete), list);
|
||
gtk_widget_show (wid);
|
||
gtk_widget_show (vbox2);
|
||
|
||
wid = gtk_option_menu_new ();
|
||
wid2 = gtk_menu_new ();
|
||
|
||
for (i = 0; i <= KEY_MAX_ACTIONS; i++)
|
||
{
|
||
wid3 = gtk_menu_item_new_with_label (_(key_actions[i].name));
|
||
gtk_widget_show (wid3);
|
||
gtk_menu_shell_append (GTK_MENU_SHELL (wid2), wid3);
|
||
gtk_signal_connect (GTK_OBJECT (wid3), "activate",
|
||
GTK_SIGNAL_FUNC (key_dialog_sel_act),
|
||
GINT_TO_POINTER (i));
|
||
}
|
||
|
||
gtk_option_menu_set_menu (GTK_OPTION_MENU (wid), wid2);
|
||
gtk_option_menu_set_history (GTK_OPTION_MENU (wid), 0);
|
||
gtk_box_pack_end (GTK_BOX (vbox2), wid, 0, 0, 0);
|
||
gtk_widget_show (wid);
|
||
key_dialog_act_menu = wid;
|
||
|
||
key_dialog_tog_s = key_dialog_make_toggle (_("Shift"), key_dialog_tog_key,
|
||
(void *) STATE_SHIFT, vbox2);
|
||
key_dialog_tog_a = key_dialog_make_toggle (_("Alt"), key_dialog_tog_key,
|
||
(void *) STATE_ALT, vbox2);
|
||
key_dialog_tog_c = key_dialog_make_toggle (_("Ctrl"), key_dialog_tog_key,
|
||
(void *) STATE_CTRL, vbox2);
|
||
|
||
key_dialog_ent_key = key_dialog_make_entry (_("Key"), "key_press_event",
|
||
key_dialog_set_key, NULL,
|
||
vbox2);
|
||
|
||
key_dialog_ent_d1 = key_dialog_make_entry (_("Data 1"), "activate",
|
||
key_dialog_set_data, NULL,
|
||
vbox2);
|
||
key_dialog_ent_d2 = key_dialog_make_entry (_("Data 2"), "activate",
|
||
key_dialog_set_data,
|
||
(void *) 1, vbox2);
|
||
|
||
hbox2 = gtk_hbox_new (0, 2);
|
||
gtk_box_pack_end (GTK_BOX (vbox), hbox2, 0, 0, 1);
|
||
|
||
wid = gtk_xtext_new (colors, 0);
|
||
gtk_widget_set_usize (wid, 0, 75);
|
||
gtk_box_pack_start (GTK_BOX (hbox2), wid, 1, 1, 1);
|
||
gtk_xtext_set_font (GTK_XTEXT (wid), prefs.hex_text_font);
|
||
gtk_widget_show (wid);
|
||
|
||
wid2 = gtk_vscrollbar_new (GTK_XTEXT (wid)->adj);
|
||
gtk_box_pack_start (GTK_BOX (hbox2), wid2, 0, 0, 0);
|
||
gtk_widget_show (wid2);
|
||
|
||
gtk_widget_show (hbox2);
|
||
key_dialog_text = wid;
|
||
|
||
gtk_widget_show_all (key_dialog);
|
||
}
|
||
|
||
static void
|
||
key_save_kbs (char *fn)
|
||
{
|
||
int fd, i;
|
||
char buf[512];
|
||
struct key_binding *kb;
|
||
|
||
if (!fn)
|
||
fd = hexchat_open_file ("keybindings.conf", O_CREAT | O_TRUNC | O_WRONLY,
|
||
0x180, XOF_DOMODE);
|
||
else
|
||
fd = hexchat_open_file (fn, O_CREAT | O_TRUNC | O_WRONLY,
|
||
0x180, XOF_DOMODE | XOF_FULLPATH);
|
||
if (fd < 0)
|
||
{
|
||
fe_message (_("Error opening keys config file\n"), FE_MSG_ERROR);
|
||
return;
|
||
}
|
||
write (fd, buf,
|
||
snprintf (buf, 510, "# HexChat key bindings config file\n\n"));
|
||
|
||
kb = keys_root;
|
||
i = 0;
|
||
|
||
while (kb)
|
||
{
|
||
if (kb->keyval == -1 || kb->keyname == NULL || kb->action < 0)
|
||
{
|
||
kb = kb->next;
|
||
continue;
|
||
}
|
||
i = 0;
|
||
if (kb->mod & STATE_CTRL)
|
||
{
|
||
i++;
|
||
write (fd, "C", 1);
|
||
}
|
||
if (kb->mod & STATE_ALT)
|
||
{
|
||
i++;
|
||
write (fd, "A", 1);
|
||
}
|
||
if (kb->mod & STATE_SHIFT)
|
||
{
|
||
i++;
|
||
write (fd, "S", 1);
|
||
}
|
||
if (i == 0)
|
||
write (fd, "None\n", 5);
|
||
else
|
||
write (fd, "\n", 1);
|
||
|
||
write (fd, buf, snprintf (buf, 510, "%s\n%s\n", kb->keyname,
|
||
key_actions[kb->action].name));
|
||
if (kb->data1 && kb->data1[0])
|
||
write (fd, buf, snprintf (buf, 510, "D1:%s\n", kb->data1));
|
||
else
|
||
write (fd, "D1!\n", 4);
|
||
|
||
if (kb->data2 && kb->data2[0])
|
||
write (fd, buf, snprintf (buf, 510, "D2:%s\n", kb->data2));
|
||
else
|
||
write (fd, "D2!\n", 4);
|
||
|
||
write (fd, "\n", 1);
|
||
|
||
kb = kb->next;
|
||
}
|
||
|
||
close (fd);
|
||
}
|
||
|
||
/* I just know this is going to be a nasty parse, if you think it's bugged
|
||
it almost certainly is so contact the HexChat dev team --AGL */
|
||
|
||
static inline int
|
||
key_load_kbs_helper_mod (char *in, int *out)
|
||
{
|
||
int n, len, mod = 0;
|
||
|
||
/* First strip off the fluff */
|
||
while (in[0] == ' ' || in[0] == '\t')
|
||
in++;
|
||
len = strlen (in);
|
||
while (in[len] == ' ' || in[len] == '\t')
|
||
{
|
||
in[len] = 0;
|
||
len--;
|
||
}
|
||
|
||
if (strcmp (in, "None") == 0)
|
||
{
|
||
*out = 0;
|
||
return 0;
|
||
}
|
||
for (n = 0; n < len; n++)
|
||
{
|
||
switch (in[n])
|
||
{
|
||
case 'C':
|
||
mod |= STATE_CTRL;
|
||
break;
|
||
case 'A':
|
||
mod |= STATE_ALT;
|
||
break;
|
||
case 'S':
|
||
mod |= STATE_SHIFT;
|
||
break;
|
||
default:
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
*out = mod;
|
||
return 0;
|
||
}
|
||
|
||
/* These are just local defines to keep me sane --AGL */
|
||
|
||
#define KBSTATE_MOD 0
|
||
#define KBSTATE_KEY 1
|
||
#define KBSTATE_ACT 2
|
||
#define KBSTATE_DT1 3
|
||
#define KBSTATE_DT2 4
|
||
|
||
/* *** Warning, Warning! - massive function ahead! --AGL */
|
||
|
||
static int
|
||
key_load_kbs (char *filename)
|
||
{
|
||
char *buf, *ibuf;
|
||
struct stat st;
|
||
struct key_binding *kb = NULL, *last = NULL;
|
||
int fd, len, pnt = 0, state = 0, n;
|
||
|
||
if (filename == NULL)
|
||
fd = hexchat_open_file ("keybindings.conf", O_RDONLY, 0, 0);
|
||
else
|
||
fd = hexchat_open_file (filename, O_RDONLY, 0, XOF_FULLPATH);
|
||
if (fd < 0)
|
||
return 1;
|
||
if (fstat (fd, &st) != 0)
|
||
return 1;
|
||
ibuf = malloc (st.st_size);
|
||
read (fd, ibuf, st.st_size);
|
||
close (fd);
|
||
|
||
while (buf_get_line (ibuf, &buf, &pnt, st.st_size))
|
||
{
|
||
if (buf[0] == '#')
|
||
continue;
|
||
if (strlen (buf) == 0)
|
||
continue;
|
||
|
||
switch (state)
|
||
{
|
||
case KBSTATE_MOD:
|
||
kb = (struct key_binding *) malloc (sizeof (struct key_binding));
|
||
if (key_load_kbs_helper_mod (buf, &kb->mod))
|
||
goto corrupt_file;
|
||
state = KBSTATE_KEY;
|
||
continue;
|
||
case KBSTATE_KEY:
|
||
/* First strip off the fluff */
|
||
while (buf[0] == ' ' || buf[0] == '\t')
|
||
buf++;
|
||
len = strlen (buf);
|
||
while (buf[len] == ' ' || buf[len] == '\t')
|
||
{
|
||
buf[len] = 0;
|
||
len--;
|
||
}
|
||
|
||
n = gdk_keyval_from_name (buf);
|
||
if (n == 0)
|
||
{
|
||
/* Unknown keyname, abort */
|
||
if (last)
|
||
last->next = NULL;
|
||
free (ibuf);
|
||
ibuf = malloc (1024);
|
||
snprintf (ibuf, 1024,
|
||
_("Unknown keyname %s in key bindings config file\nLoad aborted, please fix %s" G_DIR_SEPARATOR_S "keybindings.conf\n"),
|
||
buf, get_xdir ());
|
||
fe_message (ibuf, FE_MSG_ERROR);
|
||
free (ibuf);
|
||
return 2;
|
||
}
|
||
kb->keyname = gdk_keyval_name (n);
|
||
kb->keyval = n;
|
||
|
||
state = KBSTATE_ACT;
|
||
continue;
|
||
case KBSTATE_ACT:
|
||
/* First strip off the fluff */
|
||
while (buf[0] == ' ' || buf[0] == '\t')
|
||
buf++;
|
||
len = strlen (buf);
|
||
while (buf[len] == ' ' || buf[len] == '\t')
|
||
{
|
||
buf[len] = 0;
|
||
len--;
|
||
}
|
||
|
||
for (n = 0; n < KEY_MAX_ACTIONS + 1; n++)
|
||
{
|
||
if (strcmp (key_actions[n].name, buf) == 0)
|
||
{
|
||
kb->action = n;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (n == KEY_MAX_ACTIONS + 1)
|
||
{
|
||
if (last)
|
||
last->next = NULL;
|
||
free (ibuf);
|
||
ibuf = malloc (1024);
|
||
snprintf (ibuf, 1024,
|
||
_("Unknown action %s in key bindings config file\nLoad aborted, Please fix %s" G_DIR_SEPARATOR_S "keybindings\n"),
|
||
buf, get_xdir ());
|
||
fe_message (ibuf, FE_MSG_ERROR);
|
||
free (ibuf);
|
||
return 3;
|
||
}
|
||
state = KBSTATE_DT1;
|
||
continue;
|
||
case KBSTATE_DT1:
|
||
case KBSTATE_DT2:
|
||
if (state == KBSTATE_DT1)
|
||
kb->data1 = kb->data2 = NULL;
|
||
|
||
while (buf[0] == ' ' || buf[0] == '\t')
|
||
buf++;
|
||
|
||
if (buf[0] != 'D')
|
||
{
|
||
free (ibuf);
|
||
ibuf = malloc (1024);
|
||
snprintf (ibuf, 1024,
|
||
_("Expecting Data line (beginning Dx{:|!}) but got:\n%s\n\nLoad aborted, Please fix %s" G_DIR_SEPARATOR_S "keybindings\n"),
|
||
buf, get_xdir ());
|
||
fe_message (ibuf, FE_MSG_ERROR);
|
||
free (ibuf);
|
||
return 4;
|
||
}
|
||
switch (buf[1])
|
||
{
|
||
case '1':
|
||
if (state != KBSTATE_DT1)
|
||
goto corrupt_file;
|
||
break;
|
||
case '2':
|
||
if (state != KBSTATE_DT2)
|
||
goto corrupt_file;
|
||
break;
|
||
default:
|
||
goto corrupt_file;
|
||
}
|
||
|
||
if (buf[2] == ':')
|
||
{
|
||
len = strlen (buf);
|
||
/* Add one for the NULL, subtract 3 for the "Dx:" */
|
||
len++;
|
||
len -= 3;
|
||
if (state == KBSTATE_DT1)
|
||
{
|
||
kb->data1 = malloc (len);
|
||
memcpy (kb->data1, &buf[3], len);
|
||
} else
|
||
{
|
||
kb->data2 = malloc (len);
|
||
memcpy (kb->data2, &buf[3], len);
|
||
}
|
||
} else if (buf[2] == '!')
|
||
{
|
||
if (state == KBSTATE_DT1)
|
||
kb->data1 = NULL;
|
||
else
|
||
kb->data2 = NULL;
|
||
}
|
||
if (state == KBSTATE_DT1)
|
||
{
|
||
state = KBSTATE_DT2;
|
||
continue;
|
||
} else
|
||
{
|
||
if (last)
|
||
last->next = kb;
|
||
else
|
||
keys_root = kb;
|
||
last = kb;
|
||
|
||
state = KBSTATE_MOD;
|
||
}
|
||
|
||
continue;
|
||
}
|
||
}
|
||
if (last)
|
||
last->next = NULL;
|
||
free (ibuf);
|
||
return 0;
|
||
|
||
corrupt_file:
|
||
/*if (getenv ("HEXCHAT_DEBUG"))
|
||
abort ();*/
|
||
snprintf (ibuf, 1024,
|
||
_("Key bindings config file is corrupt, load aborted\n"
|
||
"Please fix %s" G_DIR_SEPARATOR_S "keybindings.conf\n"),
|
||
get_xdir ());
|
||
fe_message (ibuf, FE_MSG_ERROR);
|
||
free (ibuf);
|
||
free (kb);
|
||
return 5;
|
||
}
|
||
|
||
/* ***** Key actions start here *********** */
|
||
|
||
/* See the NOTES above --AGL */
|
||
|
||
/* "Run command" */
|
||
static int
|
||
key_action_handle_command (GtkWidget * wid, GdkEventKey * evt, char *d1,
|
||
char *d2, struct session *sess)
|
||
{
|
||
int ii, oi, len;
|
||
char out[2048], d = 0;
|
||
|
||
if (!d1)
|
||
return 0;
|
||
|
||
len = strlen (d1);
|
||
|
||
/* Replace each "\n" substring with '\n' */
|
||
for (ii = oi = 0; ii < len; ii++)
|
||
{
|
||
d = d1[ii];
|
||
if (d == '\\')
|
||
{
|
||
ii++;
|
||
d = d1[ii];
|
||
if (d == 'n')
|
||
out[oi++] = '\n';
|
||
else if (d == '\\')
|
||
out[oi++] = '\\';
|
||
else
|
||
{
|
||
out[oi++] = '\\';
|
||
out[oi++] = d;
|
||
}
|
||
continue;
|
||
}
|
||
out[oi++] = d;
|
||
}
|
||
out[oi] = 0;
|
||
|
||
handle_multiline (sess, out, 0, 0);
|
||
return 0;
|
||
}
|
||
|
||
/*
|
||
* Check if the given session is inside the main window. This predicate
|
||
* is passed to lastact_getfirst() as a way to filter out detached sessions.
|
||
* XXX: Consider moving this in a different file?
|
||
*/
|
||
static int
|
||
session_check_is_tab(session *sess)
|
||
{
|
||
if (!sess || !sess->gui)
|
||
return FALSE;
|
||
|
||
return (sess->gui->is_tab);
|
||
}
|
||
|
||
static int
|
||
key_action_page_switch (GtkWidget * wid, GdkEventKey * evt, char *d1,
|
||
char *d2, struct session *sess)
|
||
{
|
||
session *newsess;
|
||
int len, i, num;
|
||
|
||
if (!d1)
|
||
return 1;
|
||
|
||
len = strlen (d1);
|
||
if (!len)
|
||
return 1;
|
||
|
||
if (strcasecmp(d1, "auto") == 0)
|
||
{
|
||
/* Auto switch makes no sense in detached sessions */
|
||
if (!sess->gui->is_tab)
|
||
return 1;
|
||
|
||
/* Obtain a session with recent activity */
|
||
newsess = lastact_getfirst(session_check_is_tab);
|
||
|
||
if (newsess)
|
||
{
|
||
/*
|
||
* Only sessions in the current window should be considered (i.e.
|
||
* we don't want to move the focus on a different window). This
|
||
* call could, in theory, do this, but we checked before that
|
||
* newsess->gui->is_tab and sess->gui->is_tab.
|
||
*/
|
||
mg_bring_tofront_sess(newsess);
|
||
return 0;
|
||
}
|
||
else
|
||
return 1;
|
||
}
|
||
|
||
for (i = 0; i < len; i++)
|
||
{
|
||
if (d1[i] < '0' || d1[i] > '9')
|
||
{
|
||
if (i == 0 && (d1[i] == '+' || d1[i] == '-'))
|
||
continue;
|
||
else
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
num = atoi (d1);
|
||
if (!d2)
|
||
num--;
|
||
if (!d2 || d2[0] == 0)
|
||
mg_switch_page (FALSE, num);
|
||
else
|
||
mg_switch_page (TRUE, num);
|
||
return 0;
|
||
}
|
||
|
||
int
|
||
key_action_insert (GtkWidget * wid, GdkEventKey * evt, char *d1, char *d2,
|
||
struct session *sess)
|
||
{
|
||
int tmp_pos;
|
||
|
||
if (!d1)
|
||
return 1;
|
||
|
||
tmp_pos = SPELL_ENTRY_GET_POS (wid);
|
||
SPELL_ENTRY_INSERT (wid, d1, strlen (d1), &tmp_pos);
|
||
SPELL_ENTRY_SET_POS (wid, tmp_pos);
|
||
return 2;
|
||
}
|
||
|
||
/* handles PageUp/Down keys */
|
||
static int
|
||
key_action_scroll_page (GtkWidget * wid, GdkEventKey * evt, char *d1,
|
||
char *d2, struct session *sess)
|
||
{
|
||
int value, end;
|
||
GtkAdjustment *adj;
|
||
enum scroll_type { PAGE_TOP, PAGE_BOTTOM, PAGE_UP, PAGE_DOWN, LINE_UP, LINE_DOWN };
|
||
int type = PAGE_DOWN;
|
||
|
||
if (d1)
|
||
{
|
||
if (!g_ascii_strcasecmp (d1, "top"))
|
||
type = PAGE_TOP;
|
||
else if (!g_ascii_strcasecmp (d1, "bottom"))
|
||
type = PAGE_BOTTOM;
|
||
else if (!g_ascii_strcasecmp (d1, "up"))
|
||
type = PAGE_UP;
|
||
else if (!g_ascii_strcasecmp (d1, "down"))
|
||
type = PAGE_DOWN;
|
||
else if (!g_ascii_strcasecmp (d1, "+1"))
|
||
type = LINE_DOWN;
|
||
else if (!g_ascii_strcasecmp (d1, "-1"))
|
||
type = LINE_UP;
|
||
}
|
||
|
||
if (!sess)
|
||
return 0;
|
||
|
||
adj = gtk_range_get_adjustment (GTK_RANGE (sess->gui->vscrollbar));
|
||
end = gtk_adjustment_get_upper (adj) - gtk_adjustment_get_lower (adj) - gtk_adjustment_get_page_size (adj);
|
||
|
||
switch (type)
|
||
{
|
||
case PAGE_TOP:
|
||
value = 0;
|
||
break;
|
||
|
||
case PAGE_BOTTOM:
|
||
value = end;
|
||
break;
|
||
|
||
case PAGE_UP:
|
||
value = gtk_adjustment_get_value (adj) - (gtk_adjustment_get_page_size (adj) - 1);
|
||
break;
|
||
|
||
case PAGE_DOWN:
|
||
value = gtk_adjustment_get_value (adj) + (gtk_adjustment_get_page_size (adj) - 1);
|
||
break;
|
||
|
||
case LINE_UP:
|
||
value = gtk_adjustment_get_value (adj) - 1.0;
|
||
break;
|
||
|
||
case LINE_DOWN:
|
||
value = gtk_adjustment_get_value (adj) + 1.0;
|
||
break;
|
||
}
|
||
|
||
if (value < 0)
|
||
value = 0;
|
||
if (value > end)
|
||
value = end;
|
||
|
||
gtk_adjustment_set_value (adj, value);
|
||
|
||
return 0;
|
||
}
|
||
|
||
static int
|
||
key_action_set_buffer (GtkWidget * wid, GdkEventKey * evt, char *d1, char *d2,
|
||
struct session *sess)
|
||
{
|
||
if (!d1)
|
||
return 1;
|
||
if (d1[0] == 0)
|
||
return 1;
|
||
|
||
SPELL_ENTRY_SET_TEXT (wid, d1);
|
||
SPELL_ENTRY_SET_POS (wid, -1);
|
||
|
||
return 2;
|
||
}
|
||
|
||
static int
|
||
key_action_history_up (GtkWidget * wid, GdkEventKey * ent, char *d1, char *d2,
|
||
struct session *sess)
|
||
{
|
||
char *new_line;
|
||
|
||
new_line = history_up (&sess->history, SPELL_ENTRY_GET_TEXT (wid));
|
||
if (new_line)
|
||
{
|
||
SPELL_ENTRY_SET_TEXT (wid, new_line);
|
||
SPELL_ENTRY_SET_POS (wid, -1);
|
||
}
|
||
|
||
return 2;
|
||
}
|
||
|
||
static int
|
||
key_action_history_down (GtkWidget * wid, GdkEventKey * ent, char *d1,
|
||
char *d2, struct session *sess)
|
||
{
|
||
char *new_line;
|
||
|
||
new_line = history_down (&sess->history);
|
||
if (new_line)
|
||
{
|
||
SPELL_ENTRY_SET_TEXT (wid, new_line);
|
||
SPELL_ENTRY_SET_POS (wid, -1);
|
||
}
|
||
|
||
return 2;
|
||
}
|
||
|
||
/* old data that we reuse */
|
||
static struct gcomp_data old_gcomp;
|
||
|
||
/* work on the data, ie return only channels */
|
||
static int
|
||
double_chan_cb (session *lsess, GList **list)
|
||
{
|
||
if (lsess->type == SESS_CHANNEL)
|
||
*list = g_list_prepend(*list, lsess->channel);
|
||
return TRUE;
|
||
}
|
||
|
||
/* convert a slist -> list. */
|
||
static GList *
|
||
chanlist_double_list (GSList *inlist)
|
||
{
|
||
GList *list = NULL;
|
||
g_slist_foreach(inlist, (GFunc)double_chan_cb, &list);
|
||
return list;
|
||
}
|
||
|
||
/* handle commands */
|
||
static int
|
||
double_cmd_cb (struct popup *pop, GList **list)
|
||
{
|
||
*list = g_list_prepend(*list, pop->name);
|
||
return TRUE;
|
||
}
|
||
|
||
/* convert a slist -> list. */
|
||
static GList *
|
||
cmdlist_double_list (GSList *inlist)
|
||
{
|
||
GList *list = NULL;
|
||
g_slist_foreach (inlist, (GFunc)double_cmd_cb, &list);
|
||
return list;
|
||
}
|
||
|
||
static char *
|
||
gcomp_nick_func (char *data)
|
||
{
|
||
if (data)
|
||
return ((struct User *)data)->nick;
|
||
return "";
|
||
}
|
||
|
||
void
|
||
key_action_tab_clean(void)
|
||
{
|
||
if (old_gcomp.elen)
|
||
{
|
||
old_gcomp.data[0] = 0;
|
||
old_gcomp.elen = 0;
|
||
}
|
||
}
|
||
|
||
/* Used in the followig completers */
|
||
#define COMP_BUF 2048
|
||
|
||
/* For use in sorting the user list for completion */
|
||
static int
|
||
talked_recent_cmp (struct User *a, struct User *b)
|
||
{
|
||
if (a->lasttalk < b->lasttalk)
|
||
return -1;
|
||
|
||
if (a->lasttalk > b->lasttalk)
|
||
return 1;
|
||
|
||
return 0;
|
||
}
|
||
|
||
static int
|
||
key_action_tab_comp (GtkWidget *t, GdkEventKey *entry, char *d1, char *d2,
|
||
struct session *sess)
|
||
{
|
||
int len = 0, elen = 0, i = 0, cursor_pos, ent_start = 0, comp = 0, found = 0,
|
||
prefix_len, skip_len = 0, is_nick, is_cmd = 0;
|
||
char buf[COMP_BUF], ent[CHANLEN], *postfix = NULL, *result, *ch;
|
||
GList *list = NULL, *tmp_list = NULL;
|
||
const char *text;
|
||
GCompletion *gcomp = NULL;
|
||
|
||
/* force the IM Context to reset */
|
||
SPELL_ENTRY_SET_EDITABLE (t, FALSE);
|
||
SPELL_ENTRY_SET_EDITABLE (t, TRUE);
|
||
|
||
text = SPELL_ENTRY_GET_TEXT (t);
|
||
if (text[0] == 0)
|
||
return 1;
|
||
|
||
len = g_utf8_strlen (text, -1); /* must be null terminated */
|
||
|
||
cursor_pos = SPELL_ENTRY_GET_POS (t);
|
||
|
||
buf[0] = 0; /* make sure we don't get garbage in the buffer */
|
||
|
||
/* handle "nick: " or "nick " or "#channel "*/
|
||
ch = g_utf8_find_prev_char(text, g_utf8_offset_to_pointer(text,cursor_pos));
|
||
if (ch && ch[0] == ' ')
|
||
{
|
||
skip_len++;
|
||
ch = g_utf8_find_prev_char(text, ch);
|
||
if (!ch)
|
||
return 2;
|
||
|
||
cursor_pos = g_utf8_pointer_to_offset(text, ch);
|
||
if (cursor_pos && (g_utf8_get_char_validated(ch, -1) == ':' ||
|
||
g_utf8_get_char_validated(ch, -1) == ',' ||
|
||
g_utf8_get_char_validated (ch, -1) == g_utf8_get_char_validated (prefs.hex_completion_suffix, -1)))
|
||
{
|
||
skip_len++;
|
||
}
|
||
else
|
||
cursor_pos = g_utf8_pointer_to_offset(text, g_utf8_offset_to_pointer(ch, 1));
|
||
}
|
||
|
||
comp = skip_len;
|
||
|
||
/* store the text following the cursor for reinsertion later */
|
||
if ((cursor_pos + skip_len) < len)
|
||
postfix = g_utf8_offset_to_pointer(text, cursor_pos + skip_len);
|
||
|
||
for (ent_start = cursor_pos; ; --ent_start)
|
||
{
|
||
if (ent_start == 0)
|
||
break;
|
||
ch = g_utf8_offset_to_pointer(text, ent_start - 1);
|
||
if (ch && ch[0] == ' ')
|
||
break;
|
||
}
|
||
|
||
if (ent_start == 0 && text[0] == prefs.hex_input_command_char[0])
|
||
{
|
||
ent_start++;
|
||
is_cmd = 1;
|
||
}
|
||
|
||
prefix_len = ent_start;
|
||
elen = cursor_pos - ent_start;
|
||
|
||
g_utf8_strncpy (ent, g_utf8_offset_to_pointer (text, prefix_len), elen);
|
||
|
||
is_nick = (ent[0] == '#' || ent[0] == '&' || is_cmd) ? 0 : 1;
|
||
|
||
if (sess->type == SESS_DIALOG && is_nick)
|
||
{
|
||
/* tab in a dialog completes the other person's name */
|
||
if (rfc_ncasecmp (sess->channel, ent, elen) == 0)
|
||
{
|
||
result = sess->channel;
|
||
is_nick = 0;
|
||
}
|
||
else
|
||
return 2;
|
||
}
|
||
else
|
||
{
|
||
if (is_nick)
|
||
{
|
||
gcomp = g_completion_new((GCompletionFunc)gcomp_nick_func);
|
||
tmp_list = userlist_double_list(sess); /* create a temp list so we can free the memory */
|
||
if (prefs.hex_completion_sort == 1) /* sort in last-talk order? */
|
||
tmp_list = g_list_sort (tmp_list, (void *)talked_recent_cmp);
|
||
}
|
||
else
|
||
{
|
||
gcomp = g_completion_new (NULL);
|
||
if (is_cmd)
|
||
{
|
||
tmp_list = cmdlist_double_list (command_list);
|
||
for(i = 0; xc_cmds[i].name != NULL ; i++)
|
||
{
|
||
tmp_list = g_list_prepend (tmp_list, xc_cmds[i].name);
|
||
}
|
||
tmp_list = plugin_command_list(tmp_list);
|
||
}
|
||
else
|
||
tmp_list = chanlist_double_list (sess_list);
|
||
}
|
||
tmp_list = g_list_reverse(tmp_list); /* make the comp entries turn up in the right order */
|
||
g_completion_set_compare (gcomp, (GCompletionStrncmpFunc)rfc_ncasecmp);
|
||
if (tmp_list)
|
||
{
|
||
g_completion_add_items (gcomp, tmp_list);
|
||
g_list_free (tmp_list);
|
||
}
|
||
|
||
if (comp && !(rfc_ncasecmp(old_gcomp.data, ent, old_gcomp.elen) == 0))
|
||
{
|
||
key_action_tab_clean ();
|
||
comp = 0;
|
||
}
|
||
|
||
list = g_completion_complete_utf8 (gcomp, comp ? old_gcomp.data : ent, &result);
|
||
|
||
if (result == NULL) /* No matches found */
|
||
{
|
||
g_completion_free(gcomp);
|
||
return 2;
|
||
}
|
||
|
||
if (comp) /* existing completion */
|
||
{
|
||
while(list) /* find the current entry */
|
||
{
|
||
if(rfc_ncasecmp(list->data, ent, elen) == 0)
|
||
{
|
||
found = 1;
|
||
break;
|
||
}
|
||
list = list->next;
|
||
}
|
||
|
||
if (found)
|
||
{
|
||
if (!(d1 && d1[0])) /* not holding down shift */
|
||
{
|
||
if (g_list_next(list) == NULL)
|
||
list = g_list_first(list);
|
||
else
|
||
list = g_list_next(list);
|
||
}
|
||
else
|
||
{
|
||
if (g_list_previous(list) == NULL)
|
||
list = g_list_last(list);
|
||
else
|
||
list = g_list_previous(list);
|
||
}
|
||
g_free(result);
|
||
result = (char*)list->data;
|
||
}
|
||
else
|
||
{
|
||
g_free(result);
|
||
g_completion_free(gcomp);
|
||
return 2;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
strcpy(old_gcomp.data, ent);
|
||
old_gcomp.elen = elen;
|
||
|
||
/* Get the first nick and put out the data for future nickcompletes */
|
||
if (prefs.hex_completion_amount && g_list_length (list) <= prefs.hex_completion_amount)
|
||
{
|
||
g_free(result);
|
||
result = (char*)list->data;
|
||
}
|
||
else
|
||
{
|
||
/* bash style completion */
|
||
if (g_list_next(list) != NULL)
|
||
{
|
||
if (strlen (result) > elen) /* the largest common prefix is larger than nick, change the data */
|
||
{
|
||
if (prefix_len)
|
||
g_utf8_strncpy (buf, text, prefix_len);
|
||
strncat (buf, result, COMP_BUF - prefix_len);
|
||
cursor_pos = strlen (buf);
|
||
g_free(result);
|
||
if (postfix)
|
||
{
|
||
strcat (buf, " ");
|
||
strncat (buf, postfix, COMP_BUF - cursor_pos -1);
|
||
}
|
||
SPELL_ENTRY_SET_TEXT (t, buf);
|
||
SPELL_ENTRY_SET_POS (t, g_utf8_pointer_to_offset(buf, buf + cursor_pos));
|
||
buf[0] = 0;
|
||
}
|
||
else
|
||
g_free(result);
|
||
while (list)
|
||
{
|
||
len = strlen (buf); /* current buffer */
|
||
elen = strlen (list->data); /* next item to add */
|
||
if (len + elen + 2 >= COMP_BUF) /* +2 is space + null */
|
||
{
|
||
PrintText (sess, buf);
|
||
buf[0] = 0;
|
||
len = 0;
|
||
}
|
||
strcpy (buf + len, (char *) list->data);
|
||
strcpy (buf + len + elen, " ");
|
||
list = list->next;
|
||
}
|
||
PrintText (sess, buf);
|
||
g_completion_free(gcomp);
|
||
return 2;
|
||
}
|
||
/* Only one matching entry */
|
||
g_free(result);
|
||
result = list->data;
|
||
}
|
||
}
|
||
}
|
||
|
||
if(result)
|
||
{
|
||
if (prefix_len)
|
||
g_utf8_strncpy(buf, text, prefix_len);
|
||
strncat (buf, result, COMP_BUF - (prefix_len + 3)); /* make sure nicksuffix and space fits */
|
||
if(!prefix_len && is_nick)
|
||
strcat (buf, &prefs.hex_completion_suffix[0]);
|
||
strcat (buf, " ");
|
||
cursor_pos = strlen (buf);
|
||
if (postfix)
|
||
strncat (buf, postfix, COMP_BUF - cursor_pos - 2);
|
||
SPELL_ENTRY_SET_TEXT (t, buf);
|
||
SPELL_ENTRY_SET_POS (t, g_utf8_pointer_to_offset(buf, buf + cursor_pos));
|
||
}
|
||
if (gcomp)
|
||
g_completion_free(gcomp);
|
||
return 2;
|
||
}
|
||
#undef COMP_BUF
|
||
|
||
static int
|
||
key_action_comp_chng (GtkWidget * wid, GdkEventKey * ent, char *d1, char *d2,
|
||
struct session *sess)
|
||
{
|
||
key_action_tab_comp(wid, ent, d1, d2, sess);
|
||
return 2;
|
||
}
|
||
|
||
|
||
static int
|
||
key_action_replace (GtkWidget * wid, GdkEventKey * ent, char *d1, char *d2,
|
||
struct session *sess)
|
||
{
|
||
replace_handle (wid);
|
||
return 1;
|
||
}
|
||
|
||
|
||
static int
|
||
key_action_move_tab_left (GtkWidget * wid, GdkEventKey * ent, char *d1,
|
||
char *d2, struct session *sess)
|
||
{
|
||
mg_move_tab (sess, +1);
|
||
return 2; /* don't allow default action */
|
||
}
|
||
|
||
static int
|
||
key_action_move_tab_right (GtkWidget * wid, GdkEventKey * ent, char *d1,
|
||
char *d2, struct session *sess)
|
||
{
|
||
mg_move_tab (sess, -1);
|
||
return 2; /* -''- */
|
||
}
|
||
|
||
static int
|
||
key_action_move_tab_family_left (GtkWidget * wid, GdkEventKey * ent, char *d1,
|
||
char *d2, struct session *sess)
|
||
{
|
||
mg_move_tab_family (sess, +1);
|
||
return 2; /* don't allow default action */
|
||
}
|
||
|
||
static int
|
||
key_action_move_tab_family_right (GtkWidget * wid, GdkEventKey * ent, char *d1,
|
||
char *d2, struct session *sess)
|
||
{
|
||
mg_move_tab_family (sess, -1);
|
||
return 2; /* -''- */
|
||
}
|
||
|
||
static int
|
||
key_action_put_history (GtkWidget * wid, GdkEventKey * ent, char *d1,
|
||
char *d2, struct session *sess)
|
||
{
|
||
history_add (&sess->history, SPELL_ENTRY_GET_TEXT (wid));
|
||
SPELL_ENTRY_SET_TEXT (wid, "");
|
||
return 2; /* -''- */
|
||
}
|
||
|
||
|
||
/* -------- */
|
||
|
||
static void
|
||
replace_handle (GtkWidget *t)
|
||
{
|
||
const char *text, *postfix_pnt;
|
||
struct popup *pop;
|
||
GSList *list = replace_list;
|
||
char word[256];
|
||
char postfix[256];
|
||
char outbuf[4096];
|
||
int c, len, xlen;
|
||
|
||
text = SPELL_ENTRY_GET_TEXT (t);
|
||
|
||
len = strlen (text);
|
||
if (len < 1)
|
||
return;
|
||
|
||
for (c = len - 1; c > 0; c--)
|
||
{
|
||
if (text[c] == ' ')
|
||
break;
|
||
}
|
||
if (text[c] == ' ')
|
||
c++;
|
||
xlen = c;
|
||
if (len - c >= (sizeof (word) - 12))
|
||
return;
|
||
if (len - c < 1)
|
||
return;
|
||
memcpy (word, &text[c], len - c);
|
||
word[len - c] = 0;
|
||
len = strlen (word);
|
||
if (word[0] == '\'' && word[len] == '\'')
|
||
return;
|
||
postfix_pnt = NULL;
|
||
for (c = 0; c < len; c++)
|
||
{
|
||
if (word[c] == '\'')
|
||
{
|
||
postfix_pnt = &word[c + 1];
|
||
word[c] = 0;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (postfix_pnt != NULL)
|
||
{
|
||
if (strlen (postfix_pnt) > sizeof (postfix) - 12)
|
||
return;
|
||
strcpy (postfix, postfix_pnt);
|
||
}
|
||
while (list)
|
||
{
|
||
pop = (struct popup *) list->data;
|
||
if (strcmp (pop->name, word) == 0)
|
||
{
|
||
memcpy (outbuf, text, xlen);
|
||
outbuf[xlen] = 0;
|
||
if (postfix_pnt == NULL)
|
||
snprintf (word, sizeof (word), "%s", pop->cmd);
|
||
else
|
||
snprintf (word, sizeof (word), "%s%s", pop->cmd, postfix);
|
||
strcat (outbuf, word);
|
||
SPELL_ENTRY_SET_TEXT (t, outbuf);
|
||
SPELL_ENTRY_SET_POS (t, -1);
|
||
return;
|
||
}
|
||
list = list->next;
|
||
}
|
||
}
|
||
|