* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 2, 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

#include <pluma/pluma-message-area.h>

#endif

#define MATECONF_KEY_IGNORE_VERSION MATECONF_KEY_BASE "/ignore_version"

#define WINDOW_DATA_KEY "PlumaCheckUpdatePluginWindowData"

mateconf_client_suggest_sync (plugin->priv->mateconf_client, NULL);

g_object_unref (G_OBJECT (plugin->priv->mateconf_client));

plugin->priv->mateconf_client = NULL;

}

pluma_debug_message (DEBUG_PLUGINS,

"PlumaCheckUpdatePlugin disposing");

G_OBJECT_CLASS (pluma_check_update_plugin_parent_class)->dispose (object);

}

contents);

#else

GtkWidget *content_area;

content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (infobar));

gtk_container_add (GTK_CONTAINER (content_area), contents);

#endif

gtk_label_set_selectable (GTK_LABEL (secondary_label), TRUE);

gtk_misc_set_alignment (GTK_MISC (secondary_label), 0, 0.5);

}

set_contents (message_area, hbox_content);

}

{

GError *error = NULL;

WindowData *data;

data = g_object_get_data (G_OBJECT (window),

WINDOW_DATA_KEY);

dialog = gtk_message_dialog_new (GTK_WINDOW (window),

GTK_DIALOG_DESTROY_WITH_PARENT,

GTK_MESSAGE_ERROR,

_("There was an error displaying the URI."));

gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),

else if (response_id == GTK_RESPONSE_NO)

{

WindowData *data;

data = g_object_get_data (G_OBJECT (window), WINDOW_DATA_KEY);

mateconf_client_set_string (data->plugin->priv->mateconf_client,

#if !GTK_CHECK_VERSION (2, 17, 1)

infobar = pluma_message_area_new ();

pluma_message_area_add_stock_button_with_text (PLUMA_MESSAGE_AREA (infobar),

_("_Download"),

GTK_STOCK_SAVE,

GtkWidget *button;

infobar = gtk_info_bar_new ();

button = pluma_gtk_button_new_with_stock_icon (_("_Download"),

GTK_STOCK_SAVE);

gtk_widget_show (button);

gtk_info_bar_add_button (GTK_INFO_BAR (infobar),

GTK_STOCK_CANCEL,

GTK_RESPONSE_CANCEL);

gtk_info_bar_set_message_type (GTK_INFO_BAR (infobar),

GTK_MESSAGE_INFO);

#endif

g_signal_connect (infobar, "response",

G_CALLBACK (on_response_cb),

window);

return infobar;

}

GtkWidget *infobar)

{

GtkWidget *vbox;

vbox = gtk_bin_get_child (GTK_BIN (window));

gtk_box_pack_start (GTK_BOX (vbox), infobar, FALSE, FALSE, 0);

gtk_box_reorder_child (GTK_BOX (vbox), infobar, 2);

}

GRegex *regex;

GMatchInfo *match_info;

gchar *word = NULL;

regex = g_regex_new (regex_place, 0, 0, NULL);

g_regex_match (regex, text, 0, &match_info);

while (g_match_info_matches (match_info))

{

g_free (word);

word = g_match_info_fetch (match_info, 0);

g_match_info_next (match_info, NULL);

}

g_match_info_free (match_info);

g_regex_unref (regex);

return word;

}

{

gchar **split;

gint num = 2;

if (micro != NULL)

num = 3;

split = g_strsplit (version, ".", num);

*major = atoi (split[0]);

*minor = atoi (split[1]);

if (micro != NULL)

*micro = atoi (split[2]);

g_strfreev (split);

}

gboolean newer = FALSE;

gint major1, minor1, micro1;

gint major2, minor2, micro2;

if (v1 == NULL || v2 == NULL)

return FALSE;

{

newer = TRUE;

}

return newer;

}

parse_file_version (const gchar *file)

{

gchar *p, *aux;

p = (gchar *)file;

while (*p != '\0' && !g_ascii_isdigit (*p))

{

p++;

}

if (*p == '\0')

return NULL;

aux = g_strrstr (p, "-");

if (aux == NULL)

aux = g_strrstr (p, ".");

return g_strndup (p, aux - p);

}

data = g_object_get_data (G_OBJECT (window),

WINDOW_DATA_KEY);

file_url = g_strconcat (data->url, file, NULL);

g_free (data->url);

data->url = file_url;

data->version = g_strdup (file_version);

infobar = create_infobar (window, file_version);

pack_infobar (GTK_WIDGET (window), infobar);

gtk_widget_show (infobar);

gchar **split;

gint minor;

gboolean unstable = TRUE;;

split = g_strsplit (version, ".", 2);

minor = atoi (split[1]);

g_strfreev (split);

if ((minor % 2) == 0)

unstable = FALSE;

return unstable;

}

GString *string = NULL;

gchar *unstable = NULL;

gchar *stable = NULL;

regex = g_regex_new (regex_place, 0, 0, NULL);

g_regex_match (regex, text, 0, &match_info);

while (g_match_info_matches (match_info))

{

gint end;

gint i;

g_match_info_fetch_pos (match_info, 0, NULL, &end);

string = g_string_new ("");

i = end;

while (text[i] != '/')

{

string = g_string_append_c (string, text[i]);

i++;

}

if (is_unstable (string->str))

{

g_free (unstable);

g_free (stable);

stable = g_string_free (string, FALSE);

}

g_match_info_next (match_info, NULL);

}

g_match_info_free (match_info);

g_regex_unref (regex);

if ((PLUMA_MINOR_VERSION % 2) == 0)

{

g_free (unstable);

return stable;

}

else

if (newer_version (stable, unstable, FALSE))

{

g_free (unstable);

return stable;

}

else

{

g_free (stable);

return unstable;

}

}

WindowData *data;

data = g_object_get_data (G_OBJECT (window), WINDOW_DATA_KEY);

version = get_file_page_version (msg->response_body->data,

VERSION_PLACE);

data->url = g_strconcat (PLUMA_URL, version, "/", NULL);

g_free (version);

msg2 = soup_message_new ("GET", data->url);

soup_session_queue_message (session, msg2,

(SoupSessionCallback)parse_page_file,

window);

{

SoupMessage *msg;

WindowData *data;

pluma_debug (DEBUG_PLUGINS);

data = g_slice_new (WindowData);

free_window_data);

msg = soup_message_new ("GET", PLUMA_URL);

soup_session_queue_message (PLUMA_CHECK_UPDATE_PLUGIN (plugin)->priv->session, msg,

(SoupSessionCallback)parse_page_version,

window);

{

pluma_debug (DEBUG_PLUGINS);

soup_session_abort (PLUMA_CHECK_UPDATE_PLUGIN (plugin)->priv->session);

g_object_set_data (G_OBJECT (window),

WINDOW_DATA_KEY,

NULL);

{

GObjectClass *object_class = G_OBJECT_CLASS (klass);

PlumaPluginClass *plugin_class = PLUMA_PLUGIN_CLASS (klass);

g_type_class_add_private (object_class, sizeof (PlumaCheckUpdatePluginPrivate));

object_class->finalize = pluma_check_update_plugin_finalize;

<mateconfschemafile>

<schemalist>

<schema>

<owner>pluma</owner>

<type>string</type>

<locale name="C">

class ToolLibrary(Singleton):

def __init_once__(self):

self.locations = []

def set_locations(self, datadir):

self.locations = []

if platform.platform() != 'Windows':

for d in self.get_xdg_data_dirs():

self.locations.append(datadir)

if userdir:

toolsdir = os.path.join(userdir, 'pluma/tools')

else:

self.locations.insert(0, toolsdir);

if userdir:

filename = os.path.join(userdir, 'pluma/pluma-tools.xml')

else:

if not os.path.isfile(filename):

return

return []

else:

return map(lambda x: x.strip(), value.split(','))

def _from_list(self, value):

return ','.join(value)

break

fp.close()

self.changed = False

def _set_property_if_changed(self, key, value):

if value != self._properties.get(key):

self._properties[key] = value

def set_save_files(self, value):

self._set_property_if_changed('Save-files', value)

save_files = property(get_save_files, set_save_files)

def get_languages(self):

languages = self._properties.get('Languages')

if languages: return languages

for line in fp:

if line.strip() == '':

continue

return line.startswith('#!')

# There is no property for this one because this function is quite

def save_with_script(self, script):

filename = self.library.get_full_path(self.filename, 'w')

fp = open(filename, 'w', 1)

# Make sure to first print header (shebang, modeline), then

# Parse

for line in script:

line = line.rstrip("\n")

if not inheader:

content.append(line)

elif line.startswith('#!'):

# Write out header

for line in header:

fp.write(line + "\n")

fp.write(self._dump_properties())

fp.write("\n")

for line in content:

fp.write(line + "\n")

/*

* from the sidepanel

*

* Copyright (C) 2006 - Jesse van den Kieboom <[email protected]>

#include "pluma-file-browser-messages.h"

#define WINDOW_DATA_KEY "PlumaFileBrowserPluginWindowData"

#define CAJA_CLICK_POLICY_BASE_KEY "/apps/caja/preferences"

#define CAJA_CLICK_POLICY_KEY "click_policy"

#define CAJA_ENABLE_DELETE_KEY "enable_delete"

#define PLUMA_FILE_BROWSER_PLUGIN_GET_PRIVATE(object) (G_TYPE_INSTANCE_GET_PRIVATE ((object), PLUMA_TYPE_FILE_BROWSER_PLUGIN, PlumaFileBrowserPluginPrivate))

{

gpointer dummy;

};

{

PlumaFileBrowserWidget * tree_widget;

gulong merge_id;

} PlumaFileBrowserPluginData;

static void on_uri_activated_cb (PlumaFileBrowserWidget * widget,

PlumaWindow * window);

static void on_error_cb (PlumaFileBrowserWidget * widget,

guint code,

PlumaWindow * window);

static void on_model_set_cb (PlumaFileBrowserView * widget,

GParamSpec *arg1,

filetree_plugin_finalize (GObject * object)

{

//PlumaFileBrowserPlugin * plugin = PLUMA_FILE_BROWSER_PLUGIN (object);

G_OBJECT_CLASS (filetree_plugin_parent_class)->finalize (object);

}

return (PlumaFileBrowserPluginData *) (g_object_get_data (G_OBJECT (window), WINDOW_DATA_KEY));

}

on_end_loading_cb (PlumaFileBrowserStore * store,

GtkTreeIter * iter,

PlumaFileBrowserPluginData * data)

data->end_loading_handle = 0;

}

"end-loading",

G_CALLBACK (on_end_loading_cb),

data);

}

restore_default_location (PlumaFileBrowserPluginData *data)

{

gchar * root;

pluma_file_browser_widget_show_bookmarks (data->tree_widget);

return;

}

NULL);

NULL);

remote = mateconf_client_get_bool (client,

if (remote || g_file_is_native (file)) {

if (virtual_root != NULL && *virtual_root != '\0') {

prepare_auto_root (data);

root,

virtual_root);

} else {

}

static void

{

MateConfClient * client;

gchar *filter_mode;

filter_mode = mateconf_client_get_string (client,

FILE_BROWSER_BASE_KEY "/filter_mode",

NULL);

/* Filter mode */

mode = pluma_file_browser_store_filter_mode_get_default ();

if (filter_mode != NULL) {

if (strcmp (filter_mode, "hidden") == 0) {

mode = PLUMA_FILE_BROWSER_STORE_FILTER_MODE_HIDE_HIDDEN;

strcmp (filter_mode, "binary_and_hidden") == 0) {

mode = PLUMA_FILE_BROWSER_STORE_FILTER_MODE_HIDE_HIDDEN |

PLUMA_FILE_BROWSER_STORE_FILTER_MODE_HIDE_BINARY;

*filter_mode == '\0') {

mode = PLUMA_FILE_BROWSER_STORE_FILTER_MODE_NONE;

}

}

/* Set the filter mode */

pluma_file_browser_store_set_filter_mode (

pluma_file_browser_widget_get_browser_store (data->tree_widget),

FILE_BROWSER_BASE_KEY "/filter_pattern",

NULL);

pattern);

g_object_unref (client);

PlumaFileBrowserViewClickPolicy policy = PLUMA_FILE_BROWSER_VIEW_CLICK_POLICY_DOUBLE;

PlumaFileBrowserView *view;

value = mateconf_entry_get_value (entry);

if (value && value->type == MATECONF_VALUE_STRING) {

click_policy = mateconf_value_get_string (value);

policy = click_policy_from_string (click_policy);

}

view = pluma_file_browser_widget_get_browser_view (data->tree_widget);

}

static void

PlumaFileBrowserPluginData *data;

gboolean enable = FALSE;

value = mateconf_entry_get_value (entry);

if (value && value->type == MATECONF_VALUE_BOOL)

enable = mateconf_value_get_bool (value);

PlumaFileBrowserPluginData *data;

gboolean enable = FALSE;

value = mateconf_entry_get_value (entry);

if (value && value->type == MATECONF_VALUE_BOOL)

enable = mateconf_value_get_bool (value);

if (!client)

return;

CAJA_CLICK_POLICY_BASE_KEY,

MATECONF_CLIENT_PRELOAD_NONE,

NULL);

pluma_file_browser_view_set_click_policy (view, policy);

if (pref) {

CAJA_CLICK_POLICY_BASE_KEY "/" CAJA_CLICK_POLICY_KEY,

on_click_policy_changed,

data,

NULL);

g_free (pref);

}

/* Get enable_delete */

prefb = mateconf_client_get_bool (client,

CAJA_CLICK_POLICY_BASE_KEY "/" CAJA_ENABLE_DELETE_KEY,

NULL);

g_object_set (G_OBJECT (data->tree_widget), "enable-delete", prefb, NULL);

CAJA_CLICK_POLICY_BASE_KEY "/" CAJA_ENABLE_DELETE_KEY,

on_enable_delete_changed,

data,

prefb = mateconf_client_get_bool (client,

CAJA_CLICK_POLICY_BASE_KEY "/" CAJA_CONFIRM_TRASH_KEY,

NULL);

data->confirm_trash = prefb;

CAJA_CLICK_POLICY_BASE_KEY "/" CAJA_CONFIRM_TRASH_KEY,

on_confirm_trash_changed,

data,

PlumaFileBrowserPluginData *data;

data = get_plugin_data (window);

pluma_window_get_active_document (window));

}

GtkTreeIter iter;

PlumaFileBrowserStore * store;

data = get_plugin_data (window);

/* Get the current directory */

return;

store = pluma_file_browser_widget_get_browser_store (data->tree_widget);

&iter,

PLUMA_FILE_BROWSER_STORE_COLUMN_URI,

&wd,

-1);

if (wd == NULL)

return;

terminal = get_terminal ();

file = g_file_new_for_uri (wd);

local = g_file_get_path (file);

g_object_unref (file);

argv[0] = terminal;

argv[1] = NULL;

NULL,

NULL,

NULL,

NULL);

g_free (terminal);

g_free (wd);

g_free (local);

gchar * uri;

data = get_plugin_data (window);

tree_view = GTK_TREE_VIEW (pluma_file_browser_widget_get_browser_view (data->tree_widget));

model = gtk_tree_view_get_model (tree_view);

if (!PLUMA_IS_FILE_BROWSER_STORE (model))

return;

sensitive = pluma_file_browser_widget_get_selected_directory (data->tree_widget, &iter);

if (sensitive) {

&uri, -1);

sensitive = pluma_utils_uri_has_file_scheme (uri);

}

gtk_action_set_sensitive (

"OpenTerminal"),

sensitive);

}

" </popup>" \

"</ui>"

{

{"SetActiveRoot", GTK_STOCK_JUMP_TO, N_("_Set root to active document"),

NULL,

gtk_ui_manager_insert_action_group (manager, action_group, 0);

data->single_selection_action_group = action_group;

&error);

if (data->merge_id == 0) {

{

PlumaFileBrowserPluginData * data;

GtkUIManager * manager;

data = get_plugin_data (window);

manager = pluma_file_browser_widget_get_ui_manager (data->tree_widget);

gtk_ui_manager_remove_ui (manager, data->merge_id);

gtk_ui_manager_remove_action_group (manager, data->action_group);

g_object_unref (data->action_group);

}

static void

{

PlumaFileBrowserPluginData * data;

PlumaDocument * doc;

data = get_plugin_data (window);

doc = pluma_window_get_active_document (window);

"SetActiveRoot"),

!pluma_document_is_untitled (doc));

}

gchar *data_dir;

data = g_new0 (PlumaFileBrowserPluginData, 1);

data_dir = pluma_plugin_get_data_dir (plugin);

data->tree_widget = PLUMA_FILE_BROWSER_WIDGET (pluma_file_browser_widget_new (data_dir));

g_free (data_dir);

G_CALLBACK (on_confirm_no_trash_cb),

window);

(data->tree_widget))),

"changed",

G_CALLBACK (on_selection_changed_cb),

panel = pluma_window_get_side_panel (window);

GTK_ICON_SIZE_MENU);

if (pixbuf) {

image = gtk_image_new_from_pixbuf(pixbuf);

g_object_unref(pixbuf);

/* Restore filter options */

restore_filter (data);

/* Install caja preferences */

install_caja_prefs (data);

/* Connect signals to store the last visited location */

g_signal_connect (pluma_file_browser_widget_get_browser_view (data->tree_widget),

"notify::model",

"tab-added",

G_CALLBACK (on_tab_added_cb),

data);

/* Register messages on the bus */

pluma_file_browser_messages_register (window, data->tree_widget);

pluma_file_browser_messages_unregister (window);

/* Disconnect signals */

G_CALLBACK (on_tab_added_cb),

data);

client = mateconf_client_get_default ();

mateconf_client_remove_dir (client, CAJA_CLICK_POLICY_BASE_KEY, NULL);

if (data->click_policy_handle)

mateconf_client_notify_remove (client, data->click_policy_handle);

gchar * title;

GtkWidget * dlg;

PlumaFileBrowserPluginData * data;

data = get_plugin_data (window);

/* Do not show the error when the root has been set automatically */

if (data->auto_root && (code == PLUMA_FILE_BROWSER_ERROR_SET_ROOT ||

{

/* Show bookmarks */

pluma_file_browser_widget_show_bookmarks (data->tree_widget);

_("An error occurred while setting a root directory");

break;

case PLUMA_FILE_BROWSER_ERROR_LOAD_DIRECTORY:

_("An error occurred while loading a directory");

break;

default:

gtk_widget_destroy (dlg);

}

on_model_set_cb (PlumaFileBrowserView * widget,

GParamSpec *arg1,

PlumaWindow * window)

MateConfClient * client;

model = gtk_tree_view_get_model (GTK_TREE_VIEW (pluma_file_browser_widget_get_browser_view (data->tree_widget)));

if (model == NULL)

return;

client = mateconf_client_get_default ();

mateconf_client_set_bool (client,

FILE_BROWSER_BASE_KEY "/on_load/tree_view",

g_object_unref (client);

}

on_filter_mode_changed_cb (PlumaFileBrowserStore * model,

GParamSpec * param,

PlumaWindow * window)

PlumaFileBrowserStoreFilterMode mode;

client = mateconf_client_get_default ();

if (!client)

return;

mode = pluma_file_browser_store_get_filter_mode (model);

if ((mode & PLUMA_FILE_BROWSER_STORE_FILTER_MODE_HIDE_HIDDEN) &&

(mode & PLUMA_FILE_BROWSER_STORE_FILTER_MODE_HIDE_BINARY)) {

mateconf_client_set_string (client,

mateconf_client_set_string (client,

FILE_BROWSER_BASE_KEY "/filter_mode",

"hidden",

} else if (mode & PLUMA_FILE_BROWSER_STORE_FILTER_MODE_HIDE_BINARY) {

mateconf_client_set_string (client,

FILE_BROWSER_BASE_KEY "/filter_mode",

"none",

NULL);

}

g_object_unref (client);

}

static void

GFile * oldfile;

GFile * newfile;

gchar * uri;

/* Find all documents and set its uri to newuri where it matches olduri */

app = pluma_app_get_default ();

documents = pluma_app_get_documents (app);

oldfile = g_file_new_for_uri (olduri);

newfile = g_file_new_for_uri (newuri);

for (item = documents; item; item = item->next) {

doc = PLUMA_DOCUMENT (item->data);

uri = pluma_document_get_uri (doc);

if (!uri)

continue;

docfile = g_file_new_for_uri (uri);

if (g_file_equal (docfile, oldfile)) {

g_list_free (documents);

}

on_filter_pattern_changed_cb (PlumaFileBrowserWidget * widget,

GParamSpec * param,

PlumaWindow * window)

gchar * pattern;

client = mateconf_client_get_default ();

if (!client)

return;

g_object_get (G_OBJECT (widget), "filter-pattern", &pattern, NULL);

if (pattern == NULL)

mateconf_client_set_string (client,

FILE_BROWSER_BASE_KEY "/filter_pattern",

g_free (pattern);

}

on_virtual_root_changed_cb (PlumaFileBrowserStore * store,

GParamSpec * param,

{

PlumaFileBrowserPluginData * data = get_plugin_data (window);

gchar * root;

MateConfClient * client;

root = pluma_file_browser_store_get_root (store);

if (!root)

return;

client = mateconf_client_get_default ();

if (!client)

return;

FILE_BROWSER_BASE_KEY "/on_load/root",

root,

NULL);

virtual_root = pluma_file_browser_store_get_virtual_root (store);

if (!virtual_root) {

FILE_BROWSER_BASE_KEY "/on_load/virtual_root",

root,

NULL);

mateconf_client_set_string (client,

FILE_BROWSER_BASE_KEY "/on_load/virtual_root",

virtual_root,

}

G_CALLBACK (on_tab_added_cb),

data);

g_free (virtual_root);

}

on_tab_added_cb (PlumaWindow * window,

PlumaTab * tab,

PlumaFileBrowserPluginData * data)

g_object_unref (client);

/* Disconnect this signal, it's only called once */

G_CALLBACK (on_tab_added_cb),

data);

}

gtk_tree_model_get (model, &iter,

PLUMA_FILE_BROWSER_STORE_COLUMN_URI, &uri,

-1);

return pluma_file_browser_utils_uri_basename (uri);

}

}

result = pluma_file_browser_utils_confirmation_dialog (window,

NULL);

g_free (secondary);

secondary = _("If you delete an item, it is permanently lost.");

result = pluma_file_browser_utils_confirmation_dialog (window,

NULL);

g_free (message);

<mateconfschemafile>

<schemalist>

<schema>

<owner>pluma</owner>

<type>bool</type>

<default>TRUE</default>

</schema>

<schema>

<owner>pluma</owner>

<type>string</type>

<default></default>

<locale name="C">

<short>File Browser Root Directory</short>

browser plugin and onload/tree_view is TRUE.</long>

</locale>

</schema>

<schema>

<owner>pluma</owner>

<type>string</type>

<default></default>

<locale name="C">

<short>File Browser Virtual Root Directory</short>

file browser plugin when onload/tree_view is TRUE. The virtual root

must always be below the actual root.</long>

</locale>

</schema>

<schema>

<owner>pluma</owner>

<type>bool</type>

<default>FALSE</default>

</schema>

<schema>

<owner>pluma</owner>

<type>bool</type>

<default>TRUE</default>

<locale name="C">

<short>Set Location to First Document</short>

the first opened document given that the file browser hasn't been

used yet. (Thus this generally applies to opening a document from

the command line or opening it with Caja, etc.)</long>

</schema>

<schema>

<owner>pluma</owner>

<type>string</type>

<default>hidden_and_binary</default>

<locale name="C">

<short>File Browser Filter Mode</short>

<long>This value determines what files get filtered from the file

hidden_and_binary (filter both hidden and binary files).</long>

</locale>

</schema>

<schema>

<owner>pluma</owner>

<type>string</type>

<default></default>

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2, 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

__all__ = ('PythonConsoleConfig', 'PythonConsoleConfigDialog')

MATECONF_KEY_COMMAND_COLOR = MATECONF_KEY_BASE + '/command-color'

MATECONF_KEY_ERROR_COLOR = MATECONF_KEY_BASE + '/error-color'

self.config.color_command)

self.set_colorbutton_color(self._ui.get_object('colorbutton-error'),

self.config.color_error)

self._ui.connect_signals(self)

self._dialog = self._ui.get_object('dialog-config')

self._dialog.show_all()

else:

self._dialog.present()

return self._dialog

@staticmethod

def set_colorbutton_color(colorbutton, value):

try:

def on_dialog_config_destroy(self, dialog):

self._dialog = None

self._ui = None

def on_colorbutton_command_color_set(self, colorbutton):

self.config.color_command = colorbutton.get_color().to_string()

import shutil

import gtk

import pluma

import platform

pluma.Plugin.__init__(self)

self.dlg = None

library = Library()

library.set_accelerator_callback(self.accelerator_activated)

if userdir:

snippetsdir = os.path.join(userdir, 'pluma/snippets')

else:

library.set_dirs(snippetsdir, self.system_dirs())

datadirs = os.environ['XDG_DATA_DIRS']

else:

datadirs = '/usr/local/share' + os.pathsep + '/usr/share'

dirs = []

for d in datadirs.split(os.pathsep):

if os.path.isdir(d):

dirs.append(d)

dirs.append(self.get_data_dir())

return dirs

def activate(self, window):

data = WindowHelper(self)

window._snippets_plugin_data = data

def deactivate(self, window):

window._snippets_plugin_data.stop()

window._snippets_plugin_data = None

def update_ui(self, window):

window._snippets_plugin_data.update()

def create_configure_dialog(self):

if not self.dlg:

self.dlg = Manager(self.get_data_dir())

else:

self.dlg.run()

window = pluma.app_get_default().get_active_window()

if window:

self.dlg.dlg.set_transient_for(window)

return self.dlg.dlg

def accelerator_activated(self, group, obj, keyval, mod):

ret = False

/*

* pluma-sort-plugin.c

* Original author: Carlo Borreo <[email protected]>

* Ported to Pluma2 by Lee Mallabone <[email protected]>

*

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 2, 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

#define PLUMA_SORT_PLUGIN_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), PLUMA_TYPE_SORT_PLUGIN, PlumaSortPluginPrivate))

/* Key in case the plugin ever needs any settings. */

#define WINDOW_DATA_KEY "PlumaSortPluginWindowData"

#define MENU_PATH "/MenuBar/EditMenu/EditOps_6"

gtk_window_set_transient_for (GTK_WINDOW (dialog->dialog),

GTK_WINDOW (action_data->window));

gtk_window_set_modal (GTK_WINDOW (dialog->dialog),

TRUE);

manager = pluma_window_get_ui_manager (window);

data->ui_action_group = gtk_action_group_new ("PlumaSortPluginActions");

GETTEXT_PACKAGE);

gtk_action_group_add_actions_full (data->ui_action_group,

action_entries,

data->ui_id = gtk_ui_manager_new_merge_id (manager);

data,

(GDestroyNotify) free_window_data);

MENU_PATH,

"Sort",

FALSE);

update_ui_real (window,

* pluma-taglist-plugin-parser.c

* This file is part of pluma

*

*

* 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

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

/*

*

* $Id$

*/

#include "pluma-taglist-plugin-parser.h"

/* we screwed up so we still look here for compatibility */

#define USER_PLUMA_TAGLIST_PLUGIN_LOCATION "pluma/taglist/"

TagList *taglist = NULL;

static gint taglist_ref_count = 0;

static gboolean parse_tag (Tag *tag, xmlDocPtr doc, xmlNsPtr ns, xmlNodePtr cur);

xmlDocPtr doc, xmlNsPtr ns, xmlNodePtr cur,

gboolean sort);

xmlNsPtr ns, xmlNodePtr cur);

xmlDocPtr doc, xmlNsPtr ns, xmlNodePtr cur);

static TagList *parse_taglist_file (const gchar* filename);

static TagList *parse_taglist_dir (const gchar *dir);

static void free_tag_group (TagGroup *tag_group);

static gboolean

{

/*

pluma_debug_message (DEBUG_PLUGINS, " Tag name: %s", tag->name);

*/

/* We don't care what the top level element name is */

cur = cur->xmlChildrenNode;

{

if ((!xmlStrcmp (cur->name, (const xmlChar *)"Begin")) &&

(cur->ns == ns))

tag->begin = xmlNodeListGetString (doc, cur->xmlChildrenNode, 1);

/*

pluma_debug_message (DEBUG_PLUGINS, " - Begin: %s", tag->begin);

}

if ((!xmlStrcmp (cur->name, (const xmlChar *)"End")) &&

{

tag->end = xmlNodeListGetString (doc, cur->xmlChildrenNode, 1);

/*

{

gchar *tag_a = (gchar*)((Tag *)a)->name;

gchar *tag_b = (gchar*)((Tag *)b)->name;

return g_utf8_collate (tag_a, tag_b);

}

static gboolean

{

pluma_debug_message (DEBUG_PLUGINS, "Parse TagGroup: %s", tg->name);

/* We don't care what the top level element name is */

cur = cur->xmlChildrenNode;

{

{

g_warning ("The tag list file '%s' is of the wrong type, "

"was '%s', 'Tag' expected.", fn, cur->name);

return FALSE;

}

else

{

/* Error parsing Tag */

g_warning ("The tag list file '%s' is of the wrong type, "

fn, tag->name, tg->name);

free_tag (tag);

return FALSE;

}

}

}

}

if (sort)

tg->tags = g_list_sort (tg->tags, tags_cmp);

else

return TRUE;

}

static TagGroup*

{

TagGroup *tag_group;

xmlChar *sort_str;

/* Name found */

gboolean exists = FALSE;

GList *t = taglist->tag_groups;

/* Check if the tag group already exists */

while (t && !exists)

{

gchar *tgn = (gchar*)((TagGroup*)(t->data))->name;

if (strcmp (tgn, (gchar*)tag_group->name) == 0)

{

"Tag group '%s' already exists.", tgn);

exists = TRUE;

free_tag_group (tag_group);

}

}

if (!exists)

/* Parse tag group */

if (parse_tag_group (tag_group, filename, doc, ns, cur, sort))

{

{

/* Error parsing TagGroup */

g_warning ("The tag list file '%s' is of the wrong type, "

filename, tag_group->name);

free_tag_group (tag_group);

{

gchar *g_a = (gchar *)((TagGroup *)a)->name;

gchar *g_b = (gchar *)((TagGroup *)b)->name;

return g_utf8_collate (g_a, g_b);

}

* tags file is localized by intltool-merge below.

*

* <pluma:TagGroup name="XSLT - Elements">

* Therefore need to pick up the best lang on the current locale.

*/

static TagList*

{

TagGroup *best_tag_group = NULL;

/*

* Walk the tree.

*

*/

cur = cur->xmlChildrenNode;

while (cur != NULL)

{

g_warning ("The tag list file '%s' is of the wrong type, "

"was '%s', 'TagGroup' expected.", filename, cur->name);

lang = (gchar*) xmlGetProp (cur, (const xmlChar*) "lang");

cur_lanking = 1;

* the first section is the default lang NULL.

*/

if (lang == NULL) {

if (best_tag_group != NULL) {

g_list_prepend (taglist->tag_groups, best_tag_group);

}

best_lanking = -1;

}

* locale, ignore the logic.

*/

if (best_lanking != -1 && best_lanking <= cur_lanking) {

const gchar *best_lang = langs_pointer[i];

/*

* not find the best lang on the current locale,

* this is called.

* lists with C locale.

*/

if (lang == NULL &&

!g_ascii_strcasecmp (best_lang, "POSIX")))

{

tag_group = get_tag_group (filename, doc, ns, cur);

if (tag_group != NULL)

{

free_tag_group (best_tag_group);

best_lanking = cur_lanking;

best_tag_group = tag_group;

tag_group = get_tag_group (filename, doc, ns, cur);

if (tag_group != NULL)

{

free_tag_group (best_tag_group);

best_lanking = cur_lanking;

best_tag_group = tag_group;

if (lang) g_free (lang);

} /* End of else */

cur = cur->next;

} /* End of while (cur != NULL) */

/* Prepend TagGroup to TagList */

if (best_tag_group != NULL) {

g_list_prepend (taglist->tag_groups, best_tag_group);

}

taglist->tag_groups = g_list_sort (taglist->tag_groups, groups_cmp);

return taglist;

}

parse_taglist_file (const gchar* filename)

{

xmlDocPtr doc;

xmlNsPtr ns;

xmlNodePtr cur;

* build an XML tree from a the file;

*/

doc = xmlParseFile (filename);

return taglist;

}

/*

* Check the document is of the right kind

*/

cur = xmlDocGetRootElement (doc);

{

return taglist;

}

ns = xmlSearchNsByHref (doc, cur,

(const xmlChar *) "http://pluma.sourceforge.net/some-location");

{

g_warning ("The tag list file '%s' is of the wrong type, "

"pluma namespace not found.", filename);

xmlFreeDoc (doc);

return taglist;

}

{

g_warning ("The tag list file '%s' is of the wrong type, "

"root node != TagList.", filename);

xmlFreeDoc (doc);

return taglist;

}

* If needed, allocate taglist

*/

if (taglist == NULL)

taglist = g_new0 (TagList, 1);

taglist = lookup_best_lang (taglist, filename, doc, ns, cur);

xmlFreeDoc (doc);

pluma_debug_message (DEBUG_PLUGINS, "Really freed");

}

parse_taglist_dir (const gchar *dir)

{

GError *error = NULL;

pluma_debug_message (DEBUG_PLUGINS, "ref_count: %d", taglist_ref_count);

if (taglist_ref_count > 0)

++taglist_ref_count;

return taglist;

}

else if (home != NULL)

{

pdir = g_build_filename (home,

USER_PLUMA_TAGLIST_PLUGIN_LOCATION,

NULL);

parse_taglist_dir (pdir);

g_free (pdir);

}

pdir = g_build_filename (g_get_user_config_dir (),

"pluma",

"taglist",

parse_taglist_dir (pdir);

g_free (pdir);

#endif

/* load system's taglists */

parse_taglist_dir (data_dir);

++taglist_ref_count;

g_return_val_if_fail (taglist_ref_count == 1, taglist);

return taglist;

}

#define MENU_PATH "/MenuBar/EditMenu/EditOps_4"

/* mateconf keys */

#define PROMPT_TYPE_KEY TIME_BASE_KEY "/prompt_type"

#define SELECTED_FORMAT_KEY TIME_BASE_KEY "/selected_format"

#define CUSTOM_FORMAT_KEY TIME_BASE_KEY "/custom_format"

"time_dialog_content",

NULL

};

pluma_debug (DEBUG_PLUGINS);

dialog = g_new0 (TimeConfigureDialog, 1);

gboolean ret;

gchar *sf, *cf;

GtkWindowGroup *wg = NULL;

if (parent != NULL)

wg = gtk_window_get_group (parent);