Three parts to this patch:

1. General gtk patches

2. (from gtk_copy_crash_bug81293.patch):

Komodo was crashing at shutdown if the user performed a copy operation on a

Scintilla buffer before shutting down, bug 81293.

3. gtk-dragscroll.patch

// Copyright 1998-2004 by Neil Hodgson <neilh@scintilla.org>

// The License.txt file describes the conditions under which this software may be distributed.

#include <new>

#include <stdlib.h>

extern char *UTF8FromLatin1(const char *s, int &len);

class ScintillaGTK : public ScintillaBase {

_ScintillaObject *sci;

Window wText;

GtkAdjustment *adjustmenth;

int scrollBarWidth;

int scrollBarHeight;

// Because clipboard access is asynchronous, copyText is created by Copy

#ifndef USE_GTK_CLIPBOARD

public: // Public for scintilla_send_message

virtual sptr_t WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam);

private:

virtual sptr_t DefWndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam);

virtual void SetTicking(bool on);

virtual bool SetIdle(bool on);

virtual void ClaimSelection();

void GetGtkSelectionText(GtkSelectionData *selectionData, SelectionText &selText);

void ReceivedSelection(GtkSelectionData *selection_data);

void ReceivedDrop(GtkSelectionData *selection_data);

static void GetSelection(GtkSelectionData *selection_data, guint info, SelectionText *selected);

#ifdef USE_GTK_CLIPBOARD

void StoreOnClipboard(SelectionText *clipText);

static void ClipboardGetSelection(GtkClipboard* clip, GtkSelectionData *selection_data, guint info, void *data);

static void SelectionGet(GtkWidget *widget, GtkSelectionData *selection_data,

guint info, guint time);

static gint SelectionClear(GtkWidget *widget, GdkEventSelection *selection_event);

static void DragBegin(GtkWidget *widget, GdkDragContext *context);

gboolean DragMotionThis(GdkDragContext *context, gint x, gint y, guint dragtime);

static gboolean DragMotion(GtkWidget *widget, GdkDragContext *context,

gint x, gint y, GtkSelectionData *selection_data, guint info, guint time);

static void DragDataGet(GtkWidget *widget, GdkDragContext *context,

GtkSelectionData *selection_data, guint info, guint time);

static gboolean TimeOut(ScintillaGTK *sciThis);

static gboolean IdleCallback(ScintillaGTK *sciThis);

static gboolean StyleIdle(ScintillaGTK *sciThis);

virtual void QueueStyling(int upTo);

static sptr_t DirectFunction(ScintillaGTK *sciThis,

unsigned int iMessage, uptr_t wParam, sptr_t lParam);

};

enum {

ScintillaGTK::ScintillaGTK(_ScintillaObject *sci_) :

adjustmentv(0), adjustmenth(0),

scrollBarWidth(30), scrollBarHeight(30),

capturedMouse(false), dragWasDropped(false),

lastKey(0), rectangularSelectionModifier(SCMOD_CTRL), parentClass(0),

im_context(NULL),

lastWheelMouseDirection(0),

ScintillaGTK::~ScintillaGTK() {

g_idle_remove_by_data(this);

}

void ScintillaGTK::RealizeThis(GtkWidget *widget) {

//Platform::DebugPrintf("ScintillaGTK::realize this\n");

#if GTK_CHECK_VERSION(2,20,0)

gtk_widget_set_realized(widget, TRUE);

gint ScintillaGTK::FocusInThis(GtkWidget *widget) {

try {

if (im_context != NULL) {

gchar *str = NULL;

gint cursor_pos;

gint ScintillaGTK::FocusOutThis(GtkWidget *widget) {

try {

if (PWidget(wPreedit) != NULL)

gtk_widget_hide(PWidget(wPreedit));

}

void ScintillaGTK::SizeRequest(GtkWidget *widget, GtkRequisition *requisition) {

ScintillaGTK *sciThis = ScintillaFromWidget(widget);

requisition->height = 1;

GtkRequisition child_requisition;

#if GTK_CHECK_VERSION(3,0,0)

gtk_widget_set_can_focus(PWidget(wMain), TRUE);

gtk_widget_set_sensitive(PWidget(wMain), TRUE);

#else

GTK_WIDGET_SET_FLAGS(PWidget(wMain), GTK_CAN_FOCUS);

GTK_WIDGET_SET_FLAGS(GTK_WIDGET(PWidget(wMain)), GTK_SENSITIVE);

#endif

gtk_widget_set_events(PWidget(wMain),

GDK_EXPOSURE_MASK

gtk_widget_set_parent(PWidget(scrollbarh), PWidget(wMain));

gtk_widget_show(PWidget(scrollbarh));

gtk_drag_dest_set(GTK_WIDGET(PWidget(wMain)),

GTK_DEST_DEFAULT_ALL, clipboardPasteTargets, nClipboardPasteTargets,

static_cast<GdkDragAction>(GDK_ACTION_COPY | GDK_ACTION_MOVE));

// Set caret period based on GTK settings

gboolean blinkOn = false;

if (g_object_class_find_property(G_OBJECT_GET_CLASS(

void ScintillaGTK::StartDrag() {

dragWasDropped = false;

inDragDrop = ddDragging;

GtkTargetList *tl = gtk_target_list_new(clipboardCopyTargets, nClipboardCopyTargets);

gtk_drag_begin(GTK_WIDGET(PWidget(wMain)),

static_cast<GdkDragAction>(GDK_ACTION_COPY | GDK_ACTION_MOVE),

evbtn.button,

reinterpret_cast<GdkEvent *>(&evbtn));

}

static char *ConvertText(int *lenResult, char *s, size_t len, const char *charSetDest,

switch (iMessage) {

case SCI_GRABFOCUS:

break;

case SCI_GETDIRECTFUNCTION:

case SCI_ENCODEDFROMUTF8:

return EncodedFromUTF8(reinterpret_cast<char*>(wParam),

reinterpret_cast<char*>(lParam));

case SCI_SETRECTANGULARSELECTIONMODIFIER:

rectangularSelectionModifier = wParam;

break;

paintState = notPainting;

}

void ScintillaGTK::ScrollText(int linesToMove) {

int diff = vs.lineHeight * -linesToMove;

//Platform::DebugPrintf("ScintillaGTK::ScrollText %d %d %0d,%0d %0d,%0d\n", linesToMove, diff,

int ScintillaGTK::KeyDefault(int key, int modifiers) {

if (!(modifiers & SCI_CTRL) && !(modifiers & SCI_ALT)) {

if (key < 256) {

return 0;

} else {

// Pass up to container in case it is an accelerator

static GdkAtom TypeOfGSD(GtkSelectionData *sd) { return sd->type; }

static GdkAtom SelectionOfGSD(GtkSelectionData *sd) { return sd->selection; }

#endif

// Detect rectangular text, convert line ends to current mode, convert from or to UTF-8

void ScintillaGTK::GetGtkSelectionText(GtkSelectionData *selectionData, SelectionText &selText) {

char *dest;

if (selectionTypeData == GDK_TARGET_STRING) {

dest = Document::TransformLineEnds(&len, data, len, pdoc->eolMode);

// Unknown encoding so assume in Latin1

char *destPrevious = dest;

dest = UTF8FromLatin1(dest, len);

sel.Range(sel.Main()).Start();

if (selText.rectangular) {

} else {

InsertPaste(selStart, selText.s, selText.len);

}

EnsureCaretVisible();

}

}

void ScintillaGTK::ReceivedDrop(GtkSelectionData *selection_data) {

dragWasDropped = true;

if (TypeOfGSD(selection_data) == atomUriList || TypeOfGSD(selection_data) == atomDROPFILES_DND) {

}

Redraw();

}

void ScintillaGTK::GetSelection(GtkSelectionData *selection_data, guint info, SelectionText *text) {

if (clipBoard == NULL) // Occurs if widget isn't in a toplevel

return;

}

void ScintillaGTK::ClipboardGetSelection(GtkClipboard *, GtkSelectionData *selection_data, guint info, void *data) {

void ScintillaGTK::Resize(int width, int height) {

//Platform::DebugPrintf("Resize %d %d\n", width, height);

//printf("Resize %d %d\n", width, height);

// Not always needed, but some themes can have different sizes of scrollbars

#if GTK_CHECK_VERSION(3,0,0)

GtkRequisition requisition;

gtk_widget_get_requisition(PWidget(scrollbarv), &requisition);

if (!verticalScrollBarVisible)

alloc.width += scrollBarWidth;

gtk_widget_size_allocate(GTK_WIDGET(PWidget(wText)), &alloc);

}

static void SetAdjustmentValue(GtkAdjustment *object, int value) {

bool ctrl = (event->state & GDK_CONTROL_MASK) != 0;

if (event->button == 1) {

// On X, instead of sending literal modifiers use the user specified

// modifier, defaulting to control instead of alt.

} catch (...) {

errorStatus = SC_STATUS_FAILURE;

}

}

gint ScintillaGTK::Press(GtkWidget *widget, GdkEventButton *event) {

return TRUE;

}

void ScintillaGTK::DragBegin(GtkWidget *, GdkDragContext *) {

//Platform::DebugPrintf("DragBegin\n");

}

sciThis->errorStatus = SC_STATUS_FAILURE;

}

}

int ScintillaGTK::TimeOut(ScintillaGTK *sciThis) {

sciThis->Tick();

return 1;

}

widget_class->selection_get = SelectionGet;

widget_class->selection_clear_event = SelectionClear;

widget_class->drag_data_received = DragDataReceived;

widget_class->drag_motion = DragMotion;

widget_class->drag_leave = DragLeave;

widget_class->drag_end = DragEnd;

widget_class->drag_drop = Drop;

widget_class->drag_data_get = DragDataGet;

widget_class->realize = Realize;

widget_class->unrealize = UnRealize;

widget_class->map = Map;

#if GTK_CHECK_VERSION(2,20,0)

gtk_widget_set_can_focus(GTK_WIDGET(sci), TRUE);

#else

GTK_WIDGET_SET_FLAGS(sci, GTK_CAN_FOCUS);

#endif

sci->pscin = new ScintillaGTK(sci);

} catch (...) {

}