1 files changed, 598 insertions, 0 deletions
diff --git a/mini-commander/src/command_line.c b/mini-commander/src/command_line.c
new file mode 100644
index 00000000..ef0c8d17
--- /dev/null
+++ b/mini-commander/src/command_line.c
@@ -0,0 +1,598 @@
+/*
+ * Mini-Commander Applet
+ * Copyright (C) 1998, 1999 Oliver Maruhn <[email protected]>
+ *
+ * Author: Oliver Maruhn <[email protected]>
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <config.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <gdk/gdkkeysyms.h>
+#include <gtk/gtk.h>
+
+#include <mate-panel-applet.h>
+
+#include "mini-commander_applet.h"
+#include "command_line.h"
+#include "preferences.h"
+#include "exec.h"
+#include "cmd_completion.h"
+#include "history.h"
+
+static gint file_browser_response_signal(GtkWidget *widget, gint response, gpointer mc_data);
+static gint history_popup_clicked_cb(GtkWidget *widget, gpointer data);
+static gint history_popup_clicked_inside_cb(GtkWidget *widget, gpointer data);
+static gchar* history_auto_complete(GtkWidget *widget, GdkEventKey *event);
+
+
+static int history_position = MC_HISTORY_LIST_LENGTH;
+static gchar *browsed_folder = NULL;
+
+static gboolean
+button_press_cb (GtkEntry *entry,
+ GdkEventButton *event,
+ MCData *mc)
+{
+ const gchar *str;
+
+ mate_panel_applet_request_focus (mc->applet, event->time);
+
+ if (mc->error) {
+ mc->error = FALSE;
+ str = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
+ gtk_entry_set_text (entry, (gchar *) str + 3);
+ }
+ return FALSE;
+}
+
+static gboolean
+command_key_event (GtkEntry *entry,
+ GdkEventKey *event,
+ MCData *mc)
+{
+ guint key = event->keyval;
+ char *command;
+ static char current_command[MC_MAX_COMMAND_LENGTH];
+ char buffer[MC_MAX_COMMAND_LENGTH];
+ gboolean propagate_event = TRUE;
+ const gchar *str;
+
+ if (mc->error) {
+ mc->error = FALSE;
+ str = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
+ gtk_entry_set_text (entry, (gchar *) str + 3);
+ gtk_editable_set_position (GTK_EDITABLE (entry), strlen (str));
+ }
+ if(key == GDK_Tab
+ || key == GDK_KP_Tab
+ || key == GDK_ISO_Left_Tab)
+ {
+ if(event->state == GDK_CONTROL_MASK)
+ {
+ /*
+ * Move focus to the next widget (browser) button.
+ */
+ gtk_widget_child_focus (GTK_WIDGET (mc->applet), GTK_DIR_TAB_FORWARD);
+ propagate_event = FALSE;
+ }
+ else if(event->state != GDK_SHIFT_MASK)
+ {
+ /* tab key pressed */
+ strcpy(buffer, (char *) gtk_entry_get_text(GTK_ENTRY(entry)));
+ mc_cmd_completion (mc, buffer);
+ gtk_entry_set_text(GTK_ENTRY(entry), (gchar *) buffer);
+
+ propagate_event = FALSE;
+ }
+ }
+ else if(key == GDK_Up
+ || key == GDK_KP_Up
+ || key == GDK_ISO_Move_Line_Up
+ || key == GDK_Pointer_Up)
+ {
+ /* up key pressed */
+ if(history_position == MC_HISTORY_LIST_LENGTH)
+ {
+ /* store current command line */
+ strcpy(current_command, (char *) gtk_entry_get_text(entry));
+ }
+ if(history_position > 0 && exists_history_entry(history_position - 1))
+ {
+ gtk_entry_set_text(entry, (gchar *) get_history_entry(--history_position));
+ }
+
+ propagate_event = FALSE;
+ }
+ else if(key == GDK_Down
+ || key == GDK_KP_Down
+ || key == GDK_ISO_Move_Line_Down
+ || key == GDK_Pointer_Down)
+ {
+ /* down key pressed */
+ if(history_position < MC_HISTORY_LIST_LENGTH - 1)
+ {
+ gtk_entry_set_text(entry, (gchar *) get_history_entry(++history_position));
+ }
+ else if(history_position == MC_HISTORY_LIST_LENGTH - 1)
+ {
+ gtk_entry_set_text(entry, (gchar *) current_command);
+ ++history_position;
+ }
+
+ propagate_event = FALSE;
+ }
+ else if(key == GDK_Return
+ || key == GDK_KP_Enter
+ || key == GDK_ISO_Enter
+ || key == GDK_3270_Enter)
+ {
+ /* enter pressed -> exec command */
+ command = (char *) malloc(sizeof(char) * MC_MAX_COMMAND_LENGTH);
+ strcpy(command, (char *) gtk_entry_get_text(entry));
+ mc_exec_command(mc, command);
+
+ history_position = MC_HISTORY_LIST_LENGTH;
+ free(command);
+
+ strcpy(current_command, "");
+ propagate_event = FALSE;
+ }
+ else if (mc->preferences.auto_complete_history && key >= GDK_space && key <= GDK_asciitilde )
+ {
+ char *completed_command;
+ gint current_position = gtk_editable_get_position(GTK_EDITABLE(entry));
+
+ if(current_position != 0)
+ {
+ gtk_editable_delete_text( GTK_EDITABLE(entry), current_position, -1 );
+ completed_command = history_auto_complete(GTK_WIDGET (entry), event);
+
+ if(completed_command != NULL)
+ {
+ gtk_entry_set_text(entry, completed_command);
+ gtk_editable_set_position(GTK_EDITABLE(entry), current_position + 1);
+ propagate_event = FALSE;
+ }
+ }
+ }
+
+ return !propagate_event;
+}
+
+static gint
+history_popup_clicked_cb(GtkWidget *widget, gpointer data)
+{
+ gdk_pointer_ungrab(GDK_CURRENT_TIME);
+ gdk_keyboard_ungrab(GDK_CURRENT_TIME);
+ gtk_grab_remove(GTK_WIDGET(widget));
+ gtk_widget_destroy(GTK_WIDGET(widget));
+ widget = NULL;
+
+ /* go on */
+ return (FALSE);
+}
+
+static gint
+history_popup_clicked_inside_cb(GtkWidget *widget, gpointer data)
+{
+ /* eat signal (prevent that popup will be destroyed) */
+ return(TRUE);
+}
+
+static gboolean
+history_key_press_cb (GtkWidget *widget, GdkEventKey *event, gpointer data)
+{
+ if (event->keyval == GDK_Escape) {
+ gdk_pointer_ungrab(GDK_CURRENT_TIME);
+ gdk_keyboard_ungrab(GDK_CURRENT_TIME);
+ gtk_grab_remove(GTK_WIDGET(widget));
+ gtk_widget_destroy(GTK_WIDGET(widget));
+ widget = NULL;
+ }
+
+ return FALSE;
+
+}
+
+static gboolean
+history_list_key_press_cb (GtkWidget *widget,
+ GdkEventKey *event,
+ MCData *mc)
+{
+ GtkTreeView *tree = g_object_get_data (G_OBJECT (mc->applet), "tree");
+ GtkTreeIter iter;
+ GtkTreeModel *model;
+ gchar *command;
+
+ switch (event->keyval) {
+ case GDK_KP_Enter:
+ case GDK_ISO_Enter:
+ case GDK_3270_Enter:
+ case GDK_Return:
+ case GDK_space:
+ case GDK_KP_Space:
+ if ((event->state & GDK_CONTROL_MASK) &&
+ (event->keyval == GDK_space || event->keyval == GDK_KP_Space))
+ break;
+
+ if (!gtk_tree_selection_get_selected (gtk_tree_view_get_selection (tree),
+ &model,
+ &iter))
+ return FALSE;
+ gtk_tree_model_get (GTK_TREE_MODEL (model), &iter,
+ 0, &command, -1);
+ mc_exec_command (mc, command);
+ g_free (command);
+ gtk_widget_destroy(GTK_WIDGET(widget->parent->parent->parent));
+
+ return TRUE;
+
+ default:
+ break;
+ }
+
+ return FALSE;
+}
+
+static gboolean
+history_list_button_press_cb (GtkWidget *widget,
+ GdkEventButton *event,
+ MCData *mc)
+{
+ GtkTreeView *tree = g_object_get_data (G_OBJECT (mc->applet), "tree");
+ GtkTreeIter iter;
+ GtkTreeModel *model;
+ gchar *command;
+
+ if (event->type == GDK_2BUTTON_PRESS) {
+ if (!gtk_tree_selection_get_selected (gtk_tree_view_get_selection (tree),
+ &model,
+ &iter))
+ return FALSE;
+ gtk_tree_model_get (GTK_TREE_MODEL (model), &iter,
+ 0, &command, -1);
+ mc_exec_command(mc, command);
+ g_free (command);
+ gtk_widget_destroy(GTK_WIDGET(widget->parent->parent->parent));
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+int
+mc_show_history (GtkWidget *widget,
+ MCData *mc)
+{
+ GtkWidget *window;
+ GtkWidget *frame;
+ GtkWidget *scrolled_window;
+ GtkListStore *store;
+ GtkTreeIter iter;
+ GtkTreeModel *model;
+ GtkWidget *treeview;
+ GtkCellRenderer *cell_renderer;
+ GtkTreeViewColumn *column;
+ GtkRequisition req;
+ gchar *command_list[1];
+ int i, j;
+ gint x, y, width, height, screen_width, screen_height;
+
+ /* count commands stored in history list */
+ for(i = 0, j = 0; i < MC_HISTORY_LIST_LENGTH; i++)
+ if(exists_history_entry(i))
+ j++;
+
+ window = gtk_window_new(GTK_WINDOW_POPUP);
+ gtk_window_set_screen (GTK_WINDOW (window),
+ gtk_widget_get_screen (GTK_WIDGET (mc->applet)));
+ gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
+ gtk_window_set_type_hint(GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_COMBO);
+ /* cb */
+ g_signal_connect_after(GTK_OBJECT(window),
+ "button_press_event",
+ G_CALLBACK(history_popup_clicked_cb),
+ NULL);
+ g_signal_connect_after (G_OBJECT (window), "key_press_event",
+ G_CALLBACK (history_key_press_cb), NULL);
+
+ /* size */
+ gtk_widget_set_size_request(GTK_WIDGET(window), 200, 350);
+
+
+ /* frame */
+ frame = gtk_frame_new(NULL);
+ gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
+ gtk_widget_show(frame);
+ gtk_container_add(GTK_CONTAINER(window), frame);
+
+ /* scrollbars */
+ /* create scrolled window to put the Gtk_list widget inside */
+ scrolled_window=gtk_scrolled_window_new(NULL, NULL);
+ gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+ g_signal_connect(GTK_OBJECT(scrolled_window),
+ "button_press_event",
+ G_CALLBACK(history_popup_clicked_inside_cb),
+ NULL);
+ gtk_container_add(GTK_CONTAINER(frame), scrolled_window);
+ gtk_container_set_border_width (GTK_CONTAINER(scrolled_window), 2);
+ gtk_widget_show(scrolled_window);
+
+ store = gtk_list_store_new (1, G_TYPE_STRING);
+
+ /* add history entries to list */
+ if (j == 0) {
+ gtk_list_store_append (store, &iter);
+ gtk_list_store_set (store, &iter,0, _("No items in history"), -1);
+ }
+ else {
+ for(i = 0; i < MC_HISTORY_LIST_LENGTH; i++)
+ {
+ if(exists_history_entry(i))
+ {
+ command_list[0] = get_history_entry(i);
+ gtk_list_store_prepend (store, &iter);
+ gtk_list_store_set (store, &iter,0,command_list[0],-1);
+ }
+ }
+ }
+ model = GTK_TREE_MODEL(store);
+ treeview = gtk_tree_view_new_with_model (model);
+ g_object_set_data (G_OBJECT (mc->applet), "tree", treeview);
+ cell_renderer = gtk_cell_renderer_text_new ();
+ column = gtk_tree_view_column_new_with_attributes (NULL, cell_renderer,
+ "text", 0, NULL);
+ gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
+ gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
+ if (j == 0) {
+ gtk_tree_selection_set_mode( (GtkTreeSelection *)gtk_tree_view_get_selection
+ (GTK_TREE_VIEW (treeview)),
+ GTK_SELECTION_NONE);
+ }
+ else {
+ gtk_tree_selection_set_mode( (GtkTreeSelection *)gtk_tree_view_get_selection
+ (GTK_TREE_VIEW (treeview)),
+ GTK_SELECTION_SINGLE);
+ g_signal_connect (G_OBJECT (treeview), "button_press_event",
+ G_CALLBACK (history_list_button_press_cb), mc);
+ g_signal_connect (G_OBJECT (treeview), "key_press_event",
+ G_CALLBACK (history_list_key_press_cb), mc);
+ }
+
+ g_object_unref (G_OBJECT (model));
+ gtk_container_add(GTK_CONTAINER(scrolled_window),treeview);
+ gtk_widget_show (treeview);
+
+ gtk_widget_size_request (window, &req);
+ gdk_window_get_origin (GTK_WIDGET (mc->applet)->window, &x, &y);
+ gdk_window_get_geometry (GTK_WIDGET (mc->applet)->window, NULL, NULL,
+ &width, &height, NULL);
+
+ switch (mate_panel_applet_get_orient (mc->applet)) {
+ case MATE_PANEL_APPLET_ORIENT_DOWN:
+ y += height;
+ break;
+ case MATE_PANEL_APPLET_ORIENT_UP:
+ y -= req.height;
+ break;
+ case MATE_PANEL_APPLET_ORIENT_LEFT:
+ x -= req.width;
+ break;
+ case MATE_PANEL_APPLET_ORIENT_RIGHT:
+ x += width;
+ break;
+ }
+
+ screen_width = gdk_screen_width ();
+ screen_height = gdk_screen_height ();
+ x = CLAMP (x - 2, 0, MAX (0, screen_width - req.width));
+ y = CLAMP (y - 2, 0, MAX (0, screen_height - req.height));
+ gtk_window_move (GTK_WINDOW (window), x, y);
+ gtk_widget_show(window);
+
+ /* grab focus */
+ gdk_pointer_grab (window->window,
+ TRUE,
+ GDK_BUTTON_PRESS_MASK
+ | GDK_BUTTON_RELEASE_MASK
+ | GDK_ENTER_NOTIFY_MASK
+ | GDK_LEAVE_NOTIFY_MASK
+ | GDK_POINTER_MOTION_MASK,
+ NULL,
+ NULL,
+ GDK_CURRENT_TIME);
+ gdk_keyboard_grab (window->window, TRUE, GDK_CURRENT_TIME);
+ gtk_grab_add(window);
+ gtk_widget_grab_focus (treeview);
+
+ return FALSE;
+}
+
+static gint
+file_browser_response_signal(GtkWidget *widget, gint response, gpointer mc_data)
+{
+ MCData *mc = mc_data;
+ gchar *filename;
+
+ if (response == GTK_RESPONSE_OK) {
+
+ filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(mc->file_select));
+
+ if (filename != NULL) {
+ if (browsed_folder)
+ g_free (browsed_folder);
+
+ browsed_folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER(mc->file_select));
+
+ mc_exec_command(mc, filename);
+ g_free(filename);
+ }
+ }
+
+ /* destroy file select dialog */
+ gtk_widget_destroy (mc->file_select);
+ mc->file_select = NULL;
+
+ /* go on */
+ return FALSE;
+}
+
+int
+mc_show_file_browser (GtkWidget *widget,
+ MCData *mc)
+{
+ if(mc->file_select && GTK_WIDGET_VISIBLE(mc->file_select)) {
+ gtk_window_present (GTK_WINDOW (mc->file_select));
+ return TRUE;
+ }
+
+ /* build file select dialog */
+ mc->file_select = gtk_file_chooser_dialog_new((gchar *) _("Start program"),
+ NULL,
+ GTK_FILE_CHOOSER_ACTION_OPEN,
+ GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+ GTK_STOCK_EXECUTE, GTK_RESPONSE_OK,
+ NULL);
+
+ g_signal_connect(G_OBJECT(mc->file_select),
+ "response",
+ G_CALLBACK(file_browser_response_signal),
+ mc);
+
+ /* set path to last selected path */
+ if (browsed_folder)
+ gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(mc->file_select),
+ (gchar *) browsed_folder);
+
+ /* Set as modal */
+ gtk_window_set_modal(GTK_WINDOW(mc->file_select),TRUE);
+
+ gtk_window_set_screen (GTK_WINDOW (mc->file_select),
+ gtk_widget_get_screen (GTK_WIDGET (mc->applet)));
+ gtk_window_set_position (GTK_WINDOW (mc->file_select), GTK_WIN_POS_CENTER);
+
+ gtk_widget_show(mc->file_select);
+
+ return FALSE;
+}
+
+void
+mc_create_command_entry (MCData *mc)
+{
+ mc->entry = gtk_entry_new ();
+ gtk_entry_set_max_length (GTK_ENTRY (mc->entry), MC_MAX_COMMAND_LENGTH);
+
+ g_signal_connect (mc->entry, "key_press_event",
+ G_CALLBACK (command_key_event), mc);
+
+ g_signal_connect (mc->entry, "button_press_event",
+ G_CALLBACK (button_press_cb), mc);
+
+ if (!mc->preferences.show_default_theme)
+ {
+ gtk_widget_set_name (mc->entry, "minicommander-applet-entry");
+ mc_command_update_entry_color (mc);
+ }
+ else
+ gtk_widget_set_name (mc->entry,
+ "minicommander-applet-entry-default");
+
+ mc_command_update_entry_size (mc);
+
+ set_atk_name_description (mc->entry,
+ _("Command line"),
+ _("Type a command here and Mate will execute it for you"));
+}
+
+void
+mc_command_update_entry_color (MCData *mc)
+{
+ GdkColor fg;
+ GdkColor bg;
+ char *rc_string;
+
+ fg.red = mc->preferences.cmd_line_color_fg_r;
+ fg.green = mc->preferences.cmd_line_color_fg_g;
+ fg.blue = mc->preferences.cmd_line_color_fg_b;
+
+ /* FIXME: wish we had an API for this, see bug #79585 */
+ rc_string = g_strdup_printf (
+ "\n"
+ " style \"minicommander-applet-entry-style\"\n"
+ " {\n"
+ " GtkWidget::cursor-color=\"#%04x%04x%04x\"\n"
+ " }\n"
+ " widget \"*.minicommander-applet-entry\" "
+ "style \"minicommander-applet-entry-style\"\n"
+ "\n",
+ fg.red, fg.green, fg.blue);
+ gtk_rc_parse_string (rc_string);
+ g_free (rc_string);
+
+ gtk_widget_modify_text (mc->entry, GTK_STATE_NORMAL, &fg);
+ gtk_widget_modify_text (mc->entry, GTK_STATE_PRELIGHT, &fg);
+
+ bg.red = mc->preferences.cmd_line_color_bg_r;
+ bg.green = mc->preferences.cmd_line_color_bg_g;
+ bg.blue = mc->preferences.cmd_line_color_bg_b;
+
+ gtk_widget_modify_base (mc->entry, GTK_STATE_NORMAL, &bg);
+ gtk_widget_modify_base (mc->entry, GTK_STATE_PRELIGHT, &bg);
+}
+
+void
+mc_command_update_entry_size (MCData *mc)
+{
+ int size_x = -1;
+
+ size_x = mc->preferences.normal_size_x - 17;
+ if ((mc->orient == MATE_PANEL_APPLET_ORIENT_LEFT) || (mc->orient == MATE_PANEL_APPLET_ORIENT_RIGHT)) {
+ size_x = MIN(size_x, mc->preferences.panel_size_x - 17);
+ gtk_widget_set_size_request (GTK_WIDGET (mc->entry), size_x, -1);
+ } else {
+ gtk_widget_set_size_request (GTK_WIDGET (mc->entry), size_x, mc->preferences.normal_size_y+2);
+ }
+}
+
+
+/* Thanks to Halfline <[email protected]> for his initial version
+ of history_auto_complete */
+gchar *
+history_auto_complete(GtkWidget *widget, GdkEventKey *event)
+{
+ gchar current_command[MC_MAX_COMMAND_LENGTH];
+ gchar* completed_command;
+ int i;
+
+ g_snprintf(current_command, sizeof(current_command), "%s%s",
+ gtk_entry_get_text(GTK_ENTRY(widget)), event->string);
+ for(i = MC_HISTORY_LIST_LENGTH - 1; i >= 0; i--)
+ {
+ if(!exists_history_entry(i))
+ break;
+ completed_command = get_history_entry(i);
+ if(!strncmp(completed_command, current_command, strlen(current_command)))
+ return completed_command;
+ }
+
+ return NULL;
+}