Skip to content


Subversion checkout URL

You can clone with
Download ZIP
Commits on Oct 6, 2015
  1. @b4n

    Merge pull request #621 from techee/remote_mtime

    b4n authored
    Fix the "source file has been modified" issue
    Closes #605.
Commits on Oct 4, 2015
  1. @frlan
  2. @frlan
  3. @frlan

    Update of Greek translation

    frlan authored
Commits on Oct 1, 2015
  1. @techee

    Don't mix POSIX/GIO operations when opening/saving/stat()ing files

    techee authored
    GVFS uses different backends for "native" GIO operations and POSIX
    operations which use the FUSE backend. If the two kinds of operations are
    mixed, we may get races.
    The patch checks the value of file_prefs.use_gio_unsafe_file_saving and
    based on it either uses GIO operations or POSIX operations for file loading,
    saving and checking modification time.
Commits on Sep 23, 2015
  1. @konsolebox

    Update msgid for "Use multi-line matchin_g"

    konsolebox authored
    This also includes obvious changes to msgstr of some languages.
    Languages that didn't explicitly use 'l' as previous shortcut or
    didn't have 'g' on their translation were left untouched.
Commits on Sep 20, 2015
  1. @b4n

    Update Scintilla to version 3.6.1

    b4n authored
  2. @b4n
Commits on Sep 10, 2015
  1. @b4n
  2. @b4n
Commits on Sep 9, 2015
  1. @b4n
  2. @b4n

    Merge pull request #647 from konsolebox/master

    b4n authored
    Use 'g' as mnemonic key for "Use multi-line matching" instead of 'l'.
    Closes #589.
  3. @konsolebox

    Use 'g' as shortcut key for "Use multi-line matching" instead of 'l'.

    konsolebox authored
    The current shorcut key for "Use multi-line matching" conflicts with
    "In Selection" when "Use regular expressions" is enabled.  It should be
    convenient if we change it.
    We choose 'g' since other letters are already in use:
       u: "Use regular expressions"
       s: "Search for"
       e: "Use escape sequences"
       m: "Mark"
       l: "In Selection"
       t: "Match from start of word"
       i: "In Document"
       n: "Replace & Find"
       a: "Case sensitive"
       c: "Close"
       h: "Replace with"
Commits on Sep 1, 2015
  1. @elextr

    Merge pull request #638 from Akronix/master

    elextr authored
    Added multiline comment for filetypes.haskell
  2. @Akronix
Commits on Aug 25, 2015
  1. @eht16
Commits on Aug 24, 2015
  1. @b4n
Commits on Aug 23, 2015
  1. @b4n

    Merge pull request #469 from kugel-/new_hooks

    b4n authored
    Plugin loader redesign
  2. @b4n
  3. @kugel-

    plugins: Clarify which API functions may be called within geany_load_…

    kugel- authored
    Since geany_load_module() is called for non-enabled plugins you may not
    use the plugin API here yet. The only exceptions to this rule are API functions
    required for plugin registration.
    This rule is hard to enforce (would need to g_return_if_val(PLUGIN_LOADED_OK(p))
    for all API functions (well, those taking a plugin pointer anyway), so this
    rule is only documented for now.
  4. @kugel-

    plugins: separate geany_plugin_set_data() dual-use

    kugel- authored
    It was found that because geany_plugin_set_data() could be used by both
    plugin's init() and geany_load_module(), that it introduced some uncertainty
    as to when to call the free_func. init() callers might expect the call
    around the same time as cleanup() is called, while geany_load_module()
    callers expected the call at module unload time.
    It was indeed called at module unload time. But that means that init() callers
    cannot call it again reliably after in a init()->cleanup()->init() flow (when
    toggling the plugin) without fully unloading the plugin (which is what we do
    currently but that's we would want to change).
    With the separation we can actually destroy the data depending on where
    it was set and do everything unambigiously.
  5. @kugel-

    plugins: Updated doxygen for the new plugin loader

    kugel- authored
    The documentation provides a quite detailed description of the new loader
    In addition it adds a "how to transition" that briefly describes the old
    loader (for curious newcomers) and lots of hints for porting legacy
    plugins to the new loader.
  6. @kugel-

    plugins: Pass pdata to PluginCallback function by default

    kugel- authored
    If the plugin did not set its own user_data we set it to whatever it set
    with geany_plugin_register_full() or geany_plugin_set_data().
    This is particularly convinient because PluginCallback is usually statically
    allocated, at which point dynamically allocated plugin data doesn't exists yet.
  7. @kugel-

    plugins: change return codes of geany_load_module() and GeanyPluginFu…

    kugel- authored
    - The return value from geany_load_module is removed (void). It was ignored
      anyway and we have to check separately whether the plugin loaded OK or not
      anyway. If the plugin specific code fails it should simply not call
      geany_plugin_register() (which it should only call iff all other conditions
      are good).
    - GeanyPluginFuncs::init() now returns a bool to allow failing initialization.
      Some plugins might want to defer work to their init() (i.e. only do
      it when the plugin was activated by the user), and some of that work can
      possibly fail (e.g. GtkBuilder fails to load .xml).
    Note that the GUI integration of the latter is less than ideal but this kind
    of GUI/policy work is out of scope for this patch set. Therefore a plugin
    failing to init is simply removed from the PM dialog as if it became
    incompatible. However, as the code that generates the list does not call init
    they will show up again if the PM dialog is re-opened.
  8. @kugel-

    demoplugin: Adapt demoplugin to the new loader

    kugel- authored
    Demoplugin, while not installed by default, is a nice starting point
    and mini-howto. Therefore it should advertise the new loader from the
  9. @kugel-

    plugins: Refactor legacy plugin support

    kugel- authored
    With geany_plugin_set_data() the legacy plugin support can be made
    more transparent by using wrapper functions that call the actual plugin_*
    functions. This allows to remove the differentiation in code that's not
    directly concerned with actually loading plugins.
    This commit doesn't change anything except for one thing: legacy plugins now
    cannot call geany_plugin_set_data(). But it is meant for new-style plugins
  10. @kugel-

    plugins: Replace geany_plugin_register() pdata with a separate API fu…

    kugel- authored
    The API function adds a free_func parameter, and can also be called
    after geany_plugin_register(), i.e. in the plugin's init() callback. This
    fixes a by-design memory leak and gives greater flexibility.
  11. @kugel-

    plugins: Let plugins fill GeanyPlugin::callbacks instead of passing t…

    kugel- authored
    …heir own pointer
    This is easier to handle if we decide to add callbacks. Since we can
    zero-initialize callbacks before passing it to the plugin we can be certain as
    to which callbacks the plugin knew about when it was compiled. This is exactly
    the same method used for GeanyPlugin::info already and easier than inspecting
    the API version.
  12. @kugel-

    plugins: plugin loader redesign

    kugel- authored
    The old plugin loader has a number of deficiencies:
    - plugins need to export a couple of callback functions into the global namespace
    - plugins need to export data pointers, that are written by Geany
    - the exported functions have no user_data param, so there is no way to
      pass context/state back to the plugin (it needs global storage for that)
    - plugin registration is implicit, plugins have no way to not register themselves
      (it may want that due to missing runtime dependencies)
    - plugins perform the ABI/API verification, and even though we provide a
      convinience wrapper, it may get that wrong
    As a result, I designed a new loader with the following design principles
    - semantics of callbacks should not change, but they they shouldn't be mess
      with the global namespace
    - each callback receives a self-identifying param (the GeanyPlugin instance) and
      a plugin-defined data pointer for their own use
    - explicit registration through a new API function
    - in-core API/ABI checks
    The following principles shall be left unchanged:
    - The scan is done on startup and when the PM dialog is opened
    - Geany allocates GeanyPluginPrivate for each plugin, and GeanyPlugin is
      a member of it
    - Geany initially probes for the validity of the plugin, including file type
      and API/ABI check, thus Geany has the last word in determining what a
      plugin is
    - the PM dialog is updated with the proper, translated plugin information
    - the PM dialog GUI and user interaction in general is unchanged
    With the redesign, plugins export a single function: geany_load_module().
    This is called when the GModule is loaded. The main purpose of this function
    is to call geany_plugin_register() (new API function) to register the plugin.
    This is the only function that is learned about through g_module_symbol().
    Within this call the plugin should
    a) set the localized info fields of GeanyPlugin::info
    b) pass compiled-against and minimum API version as well as compiled-against
       ABI version, to allow Geany to verify compatibility
    c) pass a pointer to an instance of GeanyPluginFuncs
       which holds pointers to enhanced versions of the known callbacks (except
       configure_single which is dropped).
    d) optionally pass a plugin-private data pointer for later callbacks
    Enhanced means that all callbacks receive the GeanyPlugin pointer as the first
    and a pdata pointer as the last. pdata is private to the plugin and is set
    by geany_plugin_register().
    The callbacks need (should) not be globally defined anymore, and the global
    GeanyData, GeanyPlugin and GeanyFunctions pointers are ignored and not set
    anymore. GeanyData is available through GeanyPlugin::geany_data.
Commits on Aug 22, 2015
  1. @SiegeLord
  2. @SiegeLord

    Parse 'where' bounds correctly.

    SiegeLord authored SiegeLord committed
  3. @SiegeLord

    Update Rust keywords.

    SiegeLord authored SiegeLord committed
Commits on Aug 21, 2015
  1. @b4n

    Merge pull request #394 from SiegeLord/selection_document_mods

    b4n authored
    Make Document > Strip trailing spaces/Replace tabs/Replace spaces use
    the current selection.
Commits on Aug 18, 2015
  1. @techee

    Remove saved file's mtime check comparing it with the current time

    techee authored
    As the edited file can be a remote file on a server with a different time
    zone, the mtime can actually be in the future. In this case the check not
    only shows the misleading warning but more importantly the
    doc->priv->mtime < st.st_mtime
    check never happens and the user doesn't get the modified file prompt.
    doc->priv->mtime = time(NULL);
    to the current time on file creation isn't harmful in any way because the
    saved file's mtime is taken but it's a bit misleading so better to set it
    to 0.
Commits on Aug 16, 2015
  1. @b4n @SiegeLord

    Keep selection stable when replacing tabs and spaces

    b4n authored SiegeLord committed
Something went wrong with that request. Please try again.