Add a "monitor" parameter and return something reasonable, instead
of a useless resolution average of all the screen's monitors. Also
require a screen to be passed now.
There is now a preference option that determines whether windows
should be opened on the same monitor as before. It should be disabled
when the machine gets monitors plugged/unplugged dynamically ("laptop")
and enabled when there is a static multi-monitor setup ("wokstation").
This is merely the current simplistic policy on top of the newly added
underlying infrastructure:
- pass integer monitor numbers around in all places where we already
pass around a GdkScreen. Pass the "current" monitor to these changed
APIs, where "current" is either the monitor where the action-triggering
widget is, or if that is unavailable the monitor where the mouse is.
- add gimp_widget_get_monitor() in order to easily get to the monitor,
just like gtk_widget_get_screen().
- add screen and monitor parameters in some places that were missed
before.
- in sessionrc, save all window positions relative to the window's
monitor, and save the monitor separately, if it's not the screen's
primary monitor.
- when restoring window positions, use the stored monitor when the new
prefs options says so (use the screen's primary monitor if there is
no stored monitor), otherwise use current monitor that is now passed
around.
which filters out some implementation details but mainly all the
tool-specific options actions which only exist as redirect targets for
the generic tool opaticy, size, aspect and angle actions. Use the new
function from the shortcut editor and from action search so stuff is
consistently hidden.
and parse the profile in gimpimageprofileview.c instead of calling the
lcms plug-in. Make the app link against lcms. This is WIP because the
widget is of course the wrong place for such profile parsing code.
Fix various bugs, improve code design and efficiency, change feature
name, update the feature up to our standards (now uses GIMP preferences,
session management, less overwhelming settings...).
Also now action history is tightly tied to GimpAction and logs all
action activation (however it activates, and the show_unavailable
parameter also applies to history).
Search algorithm greatly improved with basic tokenization, better
ordering, filtering, etc.
...after in-DND image switching
This was actually two issues:
First, DND data is normally transferred on drop. In this situation the
contents of the source widget change in the middle of DND, so when the
drop happens there is nothing to transfer. Fixed this by attaching the
thing to transfer (image, item, color etc) to the GdkDragContext when
the DND operation starts, and trying to retrieve it on drop. Only when
nothing is attached we fall back to the traditional way of asking the
source widget. This is expected and an obvious fix.
Second, and not so obvious, the source part of the GTK+-internal state
of the DND operation (GtkDragSourceInfo) contains a *reference* (not a
copy) of the source widget's target list. When we change images in the
middle of DND, the source layer view's target list gets modified, and
because GtkDragSourceInfo only references it, the state of the ongoing
DND operation gets destroyed with it. Fixed this by changing
gimp_dnd_data_source_remove() to never change a source widget's target
list but instead create a new list without the removed target and
replace the source widget's list, keeping the ongoing drag's list
unaffected.
Also kept all the GIMP_LOG() stuff I added during debugging there, it
turned out to be quite useful.
Step and page increments can't be reasonable calculated or guessed
based on the GUI widget's factor, so pass them each time we call
set_factor(). This change reintroduces sane ranges for the levels tool
for != u8 images again.
Each of the following cleans up tag refcounting, fixes access to
released memory, or other small glitches. Not sure which change
actually fixed the bug:
gimp_data_remove_tag(): remove the found tag, not the passed in tag
(which is to be treated only as a value for comparison).
gimp_tagged_remove_tag(): don't continue the loop after the tag to
remove has been found, there can only be one matching tag, and the
list element has become invalid.
gimptagentry.c: keep references around for the members of
entry->common_tags, and make sure the references are always dropped
properly. In assign_tags(), reference the "add" and "remove" lists for
paranoia and safety reasons.
Allow to drop colors also on the palette view's parent viewport, so
colors can be dropped everywhere inside the scrolled window, also when
the palette view is invisible because it has zero colors. Also allow
dropping of palettes on the viewport to change the editor's active
palette.
Follows updated save+export specification.
For renamed actions (file-export and file-export-to respectively to
file-export-as and file-export to mimick file-save*), menurc from
GIMP 2.8 will be correctly migrated.
Reduce the minimum width of the "You can drop foo here" label to one
pixel, so it can be hidden as completely as possible while keeping the
label visible.
Totally WIP and later supposed to give simple access to all sorts of
things that can provide a GeglBuffer via the GimpPickable
interface. Currently only dropping of drawables and images is
supported.
When removing the container of a GimpContainerView,
gimp_container_view_remove_container() must be the last call. It was
causing a `GIMP_IS_CONTAINER (container)' failure in subsequent
gimp_container_get_children_type().
For good practice, unsetting a container works now the exact reversed
order as the setting of a container.
Wrong order of destruction functions were causing critical warnings on
g_signal_handlers_disconnect_by_func() calls.
Also g_object_ref/unref() the container because the tree handler might
hold the last ref to the container, once it's disconnected the container
could be gone.
Improvements:
- setenv/getenv() are not thread-safe, hence they should be run only at
startup before any threading occurs.
- it is counter-productive to load the huge ISO-639 XML file each time
the user opens the Preferences dialog or the text tool options.
Some languages have no 2-letter ISO-639-1. This is the case in particular
for 3 languages we have translations for: ast (Asturian), csb (Kashubian)
and nds (Low German), which have only 3-letter ISO-639-2/3 codes.
They were not visible in the list of languages in the Preferences dialog
until now.
setenv() does not behave well on some systems, in particular OSX (and
probably some BSDs), when the set value is NULL. In this case, let's
unsetenv() the environment variable instead.
Make sure an indexed image always has a colormap. This was the case
before, except one could set a NULL colormap via the PDB.
Add gimp_image_unset_colormap(), and make gimp_image_set_colormap()
never set the colormap to NULL, even if NULL is passed. Change the
only places where actual unsetting makes sense to use unset().
Make some GUI places deal gracefully with palettes/colormaps with zero
entries.
Small fix for the last commit: set a silly small initial size request
on the wrap_box so it doesn't initially request too much and breaks
dock layout deserialization.
gimp_container_grid_view_viewport_resized(): set the wrap_box'
required width to just one cell_width, not cell_width * columns. This
way it can shrink also when attached to a toolbox dock. It remains
unclear why it could nicely shrink in all other dock columns.
Showing the current system locale between square brackets in the
"System Language" item was causing some issues on some systems (showing
some very weird and long value).
This was mostly a cosmetic change anyway with limited gain. Let's
just get rid of it. The main part of the feature (each language
displayed in itself) is still there.
glib's g_getenv() doc says: "The returned string may be overwritten by
the next call to g_getenv(), g_setenv() or g_unsetenv()". And I do
g_setenv() calls just after, while I wish to keep the value intact.
As a consequence, even though the previous commit seemed to work just fine,
I duplicate the return value of g_getenv(), just to be on the safe side.
The trick works by temporarily resetting the current locale to localize
each language label in its own lang.
One exception is English that is equivalent to the "C" code, and we make
also some special exception for Chinese where there are very different
variant depending on the region.
I also ensure the "System Language" string is translated in whatever
language is the system actually set to.
- Add new enum GimpComponentType which contains u8, u16, u32 etc.
- Change GimpPrecision to be u8-linear, u8-gamma, u16-linear etc.
- Add all the needed formats to gimp-babl.c
- Bump the XCF version to 5 and make sure version 4 with the old
GimpPrecision enum values is loaded correctly
This change blows up the precision enums in "New Image" and
Image->Precision so we can test all this stuff. It is undecided what
format will be user-visible options in 2.10.
which allows adjustment-based prop widgets to display the property
value multiplied by factor. Remove gimp_prop_opacity_spin_scale_new()
because that's simply a factor of 100.0.
so we can make histograms of the gamma-corrected image data. Pass
TRUE all over the place so the histogram works perceptually. This
needs more thinking...
If we add a chain button to link x/y or width/height properties, also
add a coordinate pick button for these properties. This looks totally
ugly and is broken for most cases where it happens, but it works
nicely for e.g. gegl:fractal-explorer or gegl:grid. This clearly needs
some metadata for operation properties to be useful.
which allows to display a value different from the original
adjustment's value.
This is sortof a hack but insanely useful to map normalized config
values to a nicer range (e.g. 0.0 -> 1.0 to 0 ->100).
...PNG Description encoding error.
Don't unconditionally display all error messages from thumbnail saving.
Instead, return the error from gimp_imagefile_create_thumbnai()
and gimp_imagefile_save_thumbnail() and display it only if thumbnail
creation was the actual user-intended action (like clicking the preview
in a file dialog). Do not display the error when thumbnailing is just
a side effect of loading/saving an image.
gimp_overlay_child_size_allocate(): invalidate the old and new
position of the child, and simplify the code by calling our own
invalidate() function instead of duplicating its code.
gimp_overlay_child_expose(): process pending updates on the overlay
child's offscreen window before getting its pixmap.
...one image onto another
gimp_dock_window_display_changed(): make sure the "auto-follow-active"
logic works both ways: when the active image or display is changed in
a dockable, update the global context. Fixes multi-window mode.
gimp_context_real_set_display(): make sure a context's display and
image are always in a consistent state and never have a display that
is not display->image: when display is the same as context->display,
check that the context's image matches display->image, so that after a
gimp_context_set_display(), the context is consistent in all
cases. Fixes single-window mode.
Don't pass a NULL pointer to gimp_text_buffer_get_font_tag() because
it is dereferenced in a call to strcmp().
gimp_context_get_font_name() returns NULL when the selected text
includes spans with different fonts. Add the same special handling for
spans with inconsistent sizes too, and add comments that we should
have the same for the color.
Original patch from Massimo Valentini.
- reorder enum GimpCursorType to be in angular order
- add gimp_cursor_rotate(cursor_type, angle)
- rotate the shell's cursors automatically in the setter
We cannot simply randomy move the focus from e.g. a text entry back to
the canvas. Instead introduce global handling of "Escape" and a
"primary_focus_widget" that is always set the the image window's
active canvas. When Escape is pressed, move the focus to that primary
focus widget, or beep if it is already there. Text widgets still get
the key events before that logic and can consume the Escape.
Create all display filters with "color-config" and "color-managed"
parameters set, not only the automatically added color management
display filter. This way we don't only support removing and adding the
filter again, but also support potential other color management
modules.
Adds an icon-pixbuf property to GimpViewable that is used for a default
implementation of new_pixbuf.
Extend gimp_icon_picker to allow the user to pick non-stock icons for tool
presets (or any other class derived from GimpViewable). Icons can come
from any file GdkPixbuf can load or from image data on the clipboard.
gimp_docked_iface_get_aux_info(): always save the button bar state,
not only if it is "false" because we cannot know the default value any
longer (the button bar visibility used to always default to "true", so
saving only a non-default "false" was fine).
Set the dock window's geometry hints after the tool palette's style is
known, not after the toolbox' style is known, so we get the right tool
button dimensions for minimum size and size increments.
This was causing first a visual issue where the style editor UI would
show no default font/size/style at instanciation, but even a crash
when the user would change the font size or style (bold, italic...)
from this UI before selecting a font or writing a text.
Current implementation had 2 issues, fixed by this commit:
1/ after the file save dialog is closed, the image would not close.
2/ if you switched the visible tab before saving the new image, it
would save and close the visible tab, instead of the expected one.
When font, size or color were changed, set the text buffer's current
insert_tags just as we already do for the bold, italic etc. toggle
buttons. Changed gimp_text_style_editor_list_tags() to also return
the tags for font, size or color.
Apply and heavily modify patch from remyDev which adds "lock position"
to GimpItem, similar to "lock content". Lock position disables all
sorts of translation and transform, from the GUI and the PDB.
Cleaned up some aspects of the lock content code as well because a
second instance of similar code always shows what went wrong the first
time.
Don't allow to assign Modifier+Space shortcuts, there is so much code
dealing with Space in canvas event handling, we can't have it invoke
arbitrary actions at the same time.
Ensure a minimum size of the drop area and make sure it stays visible
at the bottom of a minimized toolbox. This wastes a few pixels at the
bottom of a toolbox that contains no dockables.
Fix default export extension to be as specified:
1. last export of this image
2. imported extension
3. last export of any image
4. png
2 and 3 were reversed in the code.
In order the fix the obvious confusion, add another file filter which
contains all the types that are savable with the dialog, name it
either "All XCF images" or "All export images", and make it the
default filter.
Reduce the requested width of the "You can drop foo here" label to 16
pixels, which makes is look a bit crappy, but at least the toolbox
becomes shrinkable to < 3 columns. Whoever keeps this empty space
around without using it shall henceforth be punished by having to see
that distorted and misplaced label.
Closing the display filter editor with a filter selected
in the listview on the right, used to produce (quitting GIMP):
==32359== Invalid write of size 8
==32359== at 0x8808DF5: g_nullify_pointer (glib/glib/gutils.c:2099)
==32359== by 0x8358781: weak_refs_notify (glib/gobject/gobject.c:2469)
==32359== by 0x4C3730A: gimp_color_display_dispose (gimp-2-8/libgimpwidgets/gimpcolordisplay.c:197)
==32359== by 0x83596A7: g_object_unref (glib/gobject/gobject.c:2986)
==32359== by 0x4C37EFA: gimp_color_display_stack_dispose (gimp-2-8/libgimpwidgets/gimpcolordisplaystack.c:150)
==32359== by 0x83596A7: g_object_unref (glib/gobject/gobject.c:2986)
==32359== by 0x53F1C3: gimp_display_shell_filter_set (gimp-2-8/app/display/gimpdisplayshell-filter.c:58)
==32359== by 0x536A50: gimp_display_shell_dispose (gimp-2-8/app/display/gimpdisplayshell.c:765)
Remove the button_release handler again, setting dnd_widget to NULL on
container change is enough to fix the crash I've seen, I added the
other handler just out of paranoia and apparently didn't test it.
Add (too) simple heuristic that connects to subsequent numeric property
widgets with a chain button if their property names have the suffixes
"x" and "y", or "width" and "height".
by having two booleans "export_backward" and "export_forward" in the
api instead of just an "export" one that would destroy the "imported
from" state. This change fixes the state of the "Overwrite" menu item,
so it stays visible until the file got either saved or exported to
another filename.
This also reverts commit a4beeecf2b, so
Ctrl-S is always invokable even if invisible.
In fact, it broke much more than that because the way XCF loading
replaced the image's mask prevented the image's "mask-changed" signal
from ever being emitted. Add private API gimp_image_take_mask() which
properly sets the mask and use it for image construction and the XCF
selection loading hack.
Add gimp_tag_has_prefix() and use it in GimpTagEntry when completing
patrially entered tag names, and fix two uses of strcmp() in
GimpTagPopup to use gimp_tag_compare_with_string().
Fix the places that passed the color by either temp_buf_data_clear()
or memset(), and assign x and y manually, they are going to vanish
completely soon.
The default value is 1.0 which is linear and the old behavior, values above
1.0 gives finer control in the lower portions of the range, the lower half of
the widget behaves like before doing small relative adjustments.
because it would require really evil hacks to honor these properties
in the gegl projection if they were on the mask, and because they
actually belong to the layer.
reset the "time" property after applying the stored setting, otherwise
explicitly storing the config as setting will also copy the time, and
the stored object will be considered to be among the automatically
stored recently used settings
Conditional jump or move depends on uninitialised value(s)
==29000== at 0x4C33CBC: gimp_color_area_set_color (gimp/libgimpwidgets/gimpcolorarea.c:425)
==29000== by 0x4C3505B: gimp_color_button_set_color (gimp/libgimpwidgets/gimpcolorbutton.c:642)
==29000== by 0x5DA5BE: gimp_text_style_editor_set_color (gimp/app/widgets/gimptextstyleeditor.c:700)
==29000== by 0x5DB0D4: gimp_text_style_editor_update_idle (gimp/app/widgets/gimptextstyleeditor.c:1090)
==29000== by 0x57E9E95: gdk_threads_dispatch (gtk-2-24/gdk/gdk.c:512)
Steps to reproduce:
<Ctrl>N <Enter> T
click on canvas
type something
select the text entered and change its color using
the color button from the text style editor
Conditional jump or move depends on uninitialised value(s)
==28871== at 0x4A09863: bcmp (/builddir/build/BUILD/valgrind-3.6.1/memcheck/mc_replace_strmem.c:692)
==28871== by 0x4C487C7: gimp_int_store_row_inserted (gimp/libgimpwidgets/gimpintstore.c:220)
==28871== by 0x8342B03: g_closure_invoke (glib/gobject/gclosure.c:774)
==28871== by 0x8353129: signal_emit_unlocked_R (glib/gobject/gsignal.c:3232)
==28871== by 0x835A72A: g_signal_emit_valist (glib/gobject/gsignal.c:3033)
==28871== by 0x835A8F1: g_signal_emit (glib/gobject/gsignal.c:3090)
==28871== by 0x529EF63: gtk_list_store_insert (gtk-2-24/gtk/gtkliststore.c:1039)
==28871== by 0x5CEB6B: gimp_stroke_editor_constructed (gimp/app/widgets/gimpstrokeeditor.c:229)
==28871== by 0x8348222: g_object_newv (glib/gobject/gobject.c:1731)
==28871== by 0x8348565: g_object_new_valist (glib/gobject/gobject.c:1820)
==28871== by 0x8348873: g_object_new (glib/gobject/gobject.c:1535)
==28871== by 0x5CEE74: gimp_stroke_editor_new (gimp/app/widgets/gimpstrokeeditor.c:320)
==28871== by 0x4C3842: stroke_dialog_new (gimp/app/dialogs/stroke-dialog.c:176)
==28871== by 0x4A3B5C: select_stroke_cmd_callback (gimp/app/actions/select-commands.c:349)
Steps to reproduce:
On a 64 bits machine run gimp-2.7
<Ctrl>N <Enter> <Ctrl>A
and activate <Edit>/Stroke Selection... (<Alt>E S)
- make it respect RTL mode better, something is still weird though
- don't fiddle with the entry's inner_border
- place label and number on the same line
- adjust size_request to respect the label's requisition
- set the label to ellipsize
Instead, either destroy the child instead of removing it, or remove
*and* destroy it in cases where the remove() api on the "parent"
doesn't match GTK+'s parent/child relation (like with all our dock
widgets). We can't rely on remove() to implicitly detstroy, because
there might be arbitrary other code holding references, such as
accessibility modules and whatnot. Most likely fixes unclear crashes
in accessibility code and other crashes we blamed GTK+ for.
One possible way to decrease the incompatibilities
between letter spacing in a tagged gtk_text_buffer
and in an equivalent pango_layout
Remove also a valgrind reported invalid write in
gimptextbuffer.c
no matter how editing was started (double click, keyboard activate, F2).
Connect to "editing-started" of the name cell and set the object's
real name directly on the GtkCellEditable, instead of trying to hack
around in the tree store before the actual editing starts.
so all the view renderers already have the right context when the
parent interface code selects the right item, which in turn requires
the context to be already set on the renderers. Fixes warnings when
dragging dockables around.
Really find a *widget* in gimp_dialog_factory_find_widget(), don't
just return the first found session info's widget. It's perfectly fine
for a session info to have a NULL widget, if that dialog is not
currently open.
- move the code that sets the tool options' "defined" and "serialize"
properties from GimpToolInto to GimpToolOptions so they are always
set correctly.
- make GimpToolOptions fix broken serialized NULL tools automatically.
- make sure a GimpToolPreset's tool options always has a tool set. If all
fails, set a NULL tool explicitly and let the logic in GimpToolOptions
find the right tool.
- set GimpToolPreset's "use" booleans to FALSE for context properties
that have no effect on the tool.
- set GimpToolPresetEditor's toggle insensitive for these properties.
Because it's generally the right thing to do, and server grabs broke
badly with input devices / client side windows.
gimpdisplayshell-grab.c: change logic to only server-grab if an event
is passed to the pointer grab/ungrab functions, but always use
gtk_grab_add/remove() which is sufficient in most cases.
gimpdisplayshell-tool-events.c: have the grab functions grab the
server only for space-bar scrolling and do all tool interaction,
including ruler clicks, with gtk_grab_add/remove(). Refactor things
a bit to also use the grab API for button-2 scrolling.
gimpdeviceinfo-coords.c: transform the event's coords to the canvas'
coordinate system, they might come from a ruler now.
This fixes the following bugs:
Bug 645315 - gimp_display_shell_pointer_grab: gdk_pointer_grab failed...
Bug 644351 - Gimp misses some strokes especially when drawing fast
Bug 645747 - Gimp is now unusable on xfce4
Dragging a channel preview (not RGBA) over a layer preview
GIMP used to print:
Gimp-Core-CRITICAL **: gimp_container_get_child_index: ...
assertion `GIMP_IS_CONTAINER (container)' failed
but don't fix it for item trees yet (refactoring only). Kill the
"exclusive liked" function which only existed because it was so easy
to have, but was always utterly useless. Prove me wrong and I will
revive it.
Add new utility function gimp_get_all_modifiers_mask() which returns
all modifiers used for "useful" things on the current platform, like
in the commit below.
and remove them from the various public construct() functions. Had to
change construction in GimpDataFactoryView slightly because of GObject
construct property constraints.
by checking for gimp_get_toggle_behavior_mask() instead of
GDK_CONTROL_MASK. This is a total hack but happens to simply
do the right thing on all platforms.
and remove it from all other places. We only want to have the virtual
modifiers when displaying a modifier string (and in some other cases,
but these are all handled internally by GTK+).
- gimp_modifiers_to_channel_op() translates a modifier state to REPLACE,
ADD, SUBTRACT or INTERSECT.
- gimp_replace_virtual_modifiers() uses gdk_keymap_add_virtual_modifiers()
to replace the physical bits in a modifier state to their virtual
counterparts (and not just adds the virtual ones like the GDK
function).
Introduced two virtual functions to a GimpViewable
'set_expanded' and 'get_expanded'
and a PROP_GROUP_ITEM_FLAGS to load/save the expanded state
of layer_groups and use them.
Add an explicit search entry, so the treeview's automatic search
popup doesn't break our grab and closes the dialog in the middle
of setting up the serach popup.
instead of checking for event->button == 3, so context menus
work correctly on the Mac. Didn't change the image menu yet
because thet requires some more refactoring.
which is look at the right modifier when checking if a key event
can invoke an accelerator. Also get the mnemonic modifier from
GTK instead of hardcoding it, and don't check for it if mnemonics
are disabled, which is the right thing to do on all platforms.
Apparently wilber_get_extents is called the first time
with a cairo_t with device_offset different than the other
times, since the path is copied the first time, afterwards
it appears offset.
Make GimpToolbox and GimpToolPalette use the GimpUIManager and
GimpDialogFactory of the top container instead of holding references
on their own. If they hold references on their own, we need to update
these when we move e.g. GimpToolbox between different top level
containers such as GimpDockWindow and GimpImageWindow. Failure to do
this cased problems talked about in bug 646794 (case 2).
This is a quick fix because the call can block and needs to be ported
to the async API. I simply disabled the entire block that gets the
icon from GIO.
In single-window mode, gimp_session_managed_set_aux_info() will set
the size of the dock areas at the sides. If we don't wait for those
areas to get their size-allocation, we can't properly restore the
docks inside them, so do that in an idle callback.
Also add a required call to gimp_test_run_mainloop_until_idle()
because of this in the 'automatic_tab_style' test.
Rememeber if image windows are opened because we want the
gimp_session_info_restore() code to run for the single-image window
once that code is in place.
When we get to gimp_dialog_factory_dialog_configure() and do
gimp_session_info_read_geometry(), the window geometry has not yet
been updated, i.e. gimp_session_info_read_geometry() gives the session
info the size of the *previous* configure event.
Solve this by giving gimp_session_info_read_geometry() the configure
event so it can use that size when availble.
If we don't do this change, then we get bogus values of the size of
image window when repeatedly switching between single- and
multi-window mode.
In gimp_session_info_restore() there is code to create a dialog from a
session info. GimpSessionInfo lives in the widgets module. Thus we
can't add restoration code that depends on a higher level module. In
particular, we can't add code to restore docks in an GimpImageWindow
since GimpImageWindow lives in the display module. And we need such
code to be able to restore a single-window mode session.
Since dialogs are defined in the dialogs module, it makes sense to
also have the code that restores a dialog in that module.
So, add a 'restore_func' member to GimpRestoreDialogFunc of type
GimpRestoreDialogFunc and move the code there.
Add GimpDockContainer::get_dock_side() and write that info in the
sessionrc file. In single-window mode, a dock can be either on the
left or right side of the image window. In a dock window however, the
side concept doesn't apply ('side' has nothing to do with what column
a dock is in in a GimpDockColumns)
Add image_window boolean to GimpDialogFactoryEntry and rename
FOREIGN_NOT_HIDEABLE() to IMAGE_WINDOW(). We need to treat image
windows a bit special when we restore a single-window mode session.
Make GimpDockContainer::get_docks() return a new list and not just a
pointer to a list so that GimpImageWindow can implement it (who needs
to merge its two GimpDockColumns lists).
Don't set the first page of the restored dockbook active if there are
less than two pages. Also add a comment that explains why we return
the dockbook even though we know that all its dockables failed to
restore.
Make GimpDockWindow implement the GimpDockContainer interface. The
plan is to make GimpImageWindow also implement the GimpDockContainer
interface when we start to session manage docks in single-window mode.
We now have to classes that contain docks, GimpDockWindow and
GimpImageWindow (in single-window mode). Introduce a GimpDockContainer
interface so we can cope with these in an abstract way.
Rename GimpSessionInfoDock::identifier to dock_type, because it isn't
really an identifier; there might be several instance with dock_type
being "gimp-dock". This is a preparation for adding an actual
'identifier' member.
which allows to restrict the scale to a range that is smaller than
that of the model GtkAdjustment. This way we can enter large values in
the entry or by dragging beyond the end of the scale, but keep a
reasonably usable scale range for "normal" values.
and completely separate configure and sanity checks for gdk-pixbuf
from GTK+, because it's now distributed as a separate package. Remove
all sorts of conditional compiling based on GDK_CHECK_VERSION() and
CAIRO_VERSION.
Window managers are such a crap. So on top of all friendly hinting and
geometry setting, simply use gtk_window_move() whenever a session
managed GtkDialog is shown. It should be very hard to ignore that, but
of course the WM has the last word no matter how hard we try.
Note: this code should be more complex and the signal connection
should happen in GimpDialogFactory. Left it in GimpSessionInfo for now
until it got a bit of testing.
It made the transform code hard to read and never belonged into the
tile manager anyway. It's a simple pixel buffer that should not know
about any position in an image. Instead, pass around the offsets of
tile managers explicitly, so everything is less obscure for the price
of having more parameters. This will also help replacing TileManagers
with GeglBuffers.
Instead, keep around a GimpFilteredContainer in GimpToolInfo that
maintains a per-tool list of presets from the global preset factory.
Turn the tool options dialog's preset Save/Restore/Edit/Delete menus
and buttons into shortcuts for managing the active tool's presets.
which is a copy of GimpFilteredContainer with s/Filtered/Tagged/ and
no other change. #if 0 GimpFilteredContainer for now and use
GimpTaggedContainer instead all over the place.
If the cursor position (or the current selection), doesn't contain any
font, font-size or color tags, display the default values from the
GimpText object instead of "nothing". Still display nothing if the
selection contains different fonts, sizes or colors.
instead of gimp_container_get_neighbor_of_active() in gimp-utils.c.
Move the additional GimpContext logic of the old function into the
callers, but use the new function in more places.
Instead, use an event box and set its state to SELECTED when the
device is active. Also cleaned up spacings and general appearance a
bit. Still a mess.
- change gimp_devices_get_list() to gimp_devices_get_manager()
- remove gimp_devices_get_current()
- let GimpDeviceStatus connect to the manager's "notify::current-device"
directly and remove device status updating code from gui.c
- cleanup in gimpdevices.c
Add a GimpDeviceManager object and take over most code from
gimpdevices.c, but leave all functions in gimpdevices.c there as
wrappers in order to make rebasing in gtk3-port simpler.
and redo how the curves tool sets its curves in order to support this
without code duplication. Also change the color of the yellow curve in
the dynamics output editor to orange because yellow is hardly visible.
Update the toggles in the treeview only if a boolean property of the
output changes, and not on *each* output change which includes each
tiny curve editing.
Also fix formatting in the whole file.
Properly distinguish between dropping after a group and into it, by
having three drop areas on a collapsed row. Still handle expanded rows
as before, but indicate dropping into visually just as on a collapsed
row.
when dealing with native window handles. Also get rid of using
GdkNativeWindow and simply consistently use guint32 all over the
place. This is more obvious and consistent and keeps the diff to the
gtk3-port branch smaller.
- return TRUE from event handlers if we handled the event
- remove the "instant update" toggle and feature
- move the color area left of the labels now that the toggle is gone
which is supposed to set up a widget for tablet events and make sure
the context changes on device changes. "supposed" because everything
is currently horribly broken on GTK+ 2.x. Use the function for all
affected widgets except for the canvas.
Move the call to gimp_dnd_uri_list_dest_add() to the end of the DND
setup code because it adds text/plain for legacy URI DND support,
which is way too generic to be handled first.
- TYPE_SQUARE is also named SQUARE and not RECTANGLE
- serialization doesn't suffer from the changed name because it's the
default value that never gets serialized
- a lot of messy code in the ink options can be replaced by a one-liner
because the enum names now match their resp. stock items
by integrating their label instead of requiring one externally. This
way we get rid of some more labels in the tool options. Also clean up
tool options further (add more spin scales, and some general
reordering and spacing cleanup).
Instead, inherit from GtkBox directly and set the orientation in
init(). Replace more gtk_container_add() by gtk_box_pack_start() in
the reparented classes.
Remove a crack eventbox and a double crack alignment and suddenly the
widget behaves properly. I have no idea what "important" feature I
killed with that removal, but the whole palette editing code needs
some serious chopping soon.
Instead, handle the drawing offset generically by offsetting the
cairo_t in two places in the callers, and only pass the width and
height available for drawing.
Move the g_signal_emit() to the end, because the cell->renderer could
be changed and cause a segfault. Also check cell->renderer before
dereferencing it.
Change the generated tag names to use #rrggbb notation and compare the
colors on an 8 bit basis to make sure the comparison and the tag names
exist in the same set of values (otherwise the text buffer gets into
an inconsistent state that can even lead to crashes).
Introduce gimp_vectors_get_bezier() which creates the bezier
representation on demand and then caches it for subsequent calls
until the vectors object is frozen.
At some point we should introduce GimpVectors::changed instead
of relying on the fact that a vectors object is always frozen
and thawn whenever it is changed...
At the same time, get rid of bitmap cursors alltogether. Instead
(because it looks ugly to have GDK convert RGBA cursors into bitmaps
for old X servers), add the bitmaps as proper PNGs and simply use them
as RGBA cursors.
Remove "Text to Selection" actions. They were added to make the
feature more discoverable. But we should make the original "Alpha to
selection" feature more discoverable, not treating text layers in a
special way where it's not needed.
by letting the histogram view always draw the background and the outer
borders. Also fix a lot of off-by-one problems in the curve view which
occur due to the 0.5,0.5 offset of cairo line drawing.
Call cairo_surface_flush() before reading or writing a surface's
pixels directly, and use cairo_surface_mark_dirty() after writing
pixels directly, so we don't read old pixels, and our written pixels
get actually used.
Add a "pre-clicked" signal to GimpCellRendererViewable that can
prevent a selection from happening. Move the Alt-Click code in
GimpLayerTreeView to this signal and if a layer is Alt-Clicked, don't
go ahead and make the layer active. Also add a test for this use case.
Don't use an action based implementation of Alt-Click for "Layer to
selection" since the actions will always use the active drawable,
preventing us from solving bug 589010. Use the tree model and
gimp_channel_select_alpha() instead.
using the proper API, so all stuff is properly disconnected and the
list items managing them are freed to. Also make removing robust
against dockbook->dock being NULL.
This is evil: the hash table of "insert_data" is created on demand
when GimpContainerView API is used, using a value_free_func that is
set in the interface_init functions of its implementors. Therefore, no
GimpContainerView API must be called from any init() function, because
the interface_init() function of a subclass that sets the right
value_free_func might not have been called yet, leaving the
insert_data hash table without memory management.
Call GimpContainerView API from GObject::constructed() instead, which
runs after everything is set up correctly.
Don't divide by zero in gimp_session_info_class_apply_position_accuracy()
when klass->position_accuracy is 0, which happens on each exit in a normal
session.
Introduce a few pixels of error margin in sessionrc, otherwise the
tests are too fragile, widgets have a tendency to change size a bit
and window managers have a tendency to move windows a bit.
Still needs more work, should probably do the same on book positions
too...
We don't need to call gimp_dockbook_refresh_tab_layout_lut() in
added() and removed() because we call
gimp_dockbook_update_auto_tab_style() in add() and remove().
instead of never drawing a background. Doesn't make any difference,
but makes GimpOverlayBox a more general container. Also, the offscreen
GdkWindow doesn't need any event but GDK_EXPOSURE_MASK.
* app/widgets/gimpoverlaychild.c: when creating offscreen windows, try
to set an RGBA colormap on the offscreen window's widget and use the
RGBA colormap to create the window. This has to be done here,
because it's not possible to get to the right screen *inside* the
offscreen widget before it's parented, and we need that screen
before the widget is realized, and the widget can't be parented
before it's realized or it will get the wrong parent window.
Everything clear now?
* app/widgets/gimpoverlayframe.c: draw the round corners only if the
screen has an RGBA colormap.
Remove the dockable drag handle and move the menu button it hosts up
to the GimpDockbook, with the gtk_notebook_set_action_widget() API.
This frees up quite a lot of screen estate which can be used for the
content of dockables instead.
Add support for a new type of Tab Style called 'Automatic'. This tab
style makes the GimpDockbook use the biggest actual tab style it can
for its auto tab style dockables, based on its widget allocation.
The tab style candidates for auto tab style are "Status + Blurb",
"Status + Text" and "Status". A docked widget can also say that it
wants to use "Icon" instead of "Status" for its auto tab style. The
'Tool Options' dockable does this. This is to be as backwards
compatible with the old tab style setup, we make 'automatic' the
default everywhere.
We have quite a bit of dependency to internal layout code in
GtkNotebook, but the current code should be pixel perfect and rather
complete.
Also add a basic regression test.
In order to get accurate measurements of widgets that will be put in a
GimpDock, add gimp_dock_temp_add() and gimp_dock_temp_remove(). That
way we can add a widget temporarliy, measure it with the
GimpDock::font-scale property applied, then remove it when we're
done. We can't apply style properties on widget detached from a
GdkScreen hierarchy :(
This is supposed to finally replace GimpContainerGridView along with
GtkWrapBox. The code is experimental and currently even crashes
without a modified GTK+, so it's disabled. Keeping it in GIT makes
developing easier though.
Keep a list of GimpCellRendererViewable around and add API to add
them. When items are removed or the store is cleared, set the
renderers' "viewable" property to NULL so they don't keep refing the
viewable.
This is not really "model" code but needs to be done for all container
views that have viewable cell renderers.
GimpContainerComboBox and GimpContainerEntry lacked that clearing, so
this change might fix some cases where objects (even images) were
removed but still stuck in memory until the model changed again.
We need to be able to pass a GimpUIManager to
gimp_dialog_factory_dialog_new(), so make that possible. Also make
sure to set ui_manager in gimp_dialog_factory_dialog_new_internal()
when we create both a dock window and a dock, so tooltips works in
toolboxes created from scratch.
- app/widgets/gimptextstyleeditor.c: don't block all key events so
they can reach the canvas.
- app/display/gimpdisplayshell-callbacks.c: instead, ignore canvas key
events when the canvas has no focus.
This fixes navigating out of the text style editor with TAB, moving
focus to the canvas. I have no clue why navigating *between* the
widgets in the style editor doesn't work.
I had to remove the asserrt in tool preset constructor, because with it
it wasnt possible to initalize an empty model object for the editor.
At init time the gimp object passed to the constructor is not yet available.
The function gimp_dockable_get_tab_widget() and
gimp_dockable_get_drag_widget are not getters, they create new
widgets. Furthermore, gimp_dockable_get_tab_widget() doesn't use the
instance tab style but takes a tab style paramter. Rename the
functions to gimp_dockable_new_tab_widget_for_style() and
gimp_dockable_new_drag_widget() to reflect this.
and also #define the names of the properties we (ab)use, so we don't
have to use magic strings all over the place, and we don't have to use
g_object_get() either.
Refactor stuff a bit so that the dock window description can be both
short and long. The short version only have the active dockables, and
the long version have all the dockables in the description string. We
use the short version for the window title and the long version for
the Recently Closed Docks menu items.
Introduce GIMP_DIALOG_VISIBILITY_HIDDEN because it is a bit
counter-intuitive to call gtk_widget_hide() on a dialog and then set
GIMP_DIALOG_VISIBILITY_VISIBLE on it. No change in program flow has
been (deliberately) introduced.
Tag assignment has been redesigned according to Peter Sikking's
recommendations. When multiple resources are selected, common tags
to all of them are listed in tag asignment widget. On assignment
it is detected which tags were added and removed from common tag set
and the selected resources are updated accordingly (instead of
replacing their previous tags).
Implemented infrastructure for multiple selection support.
GimpContainerTreeView actually provides such functionality.
All other GimpContainerViews should work as before.
Only remove a dock in the book-removed callback to dock columns if the
dock has the dock column as parent. It won't during destruction for
example. This fixes the test case
/gimp-ui/restore-recently-closed-multi-column-dock.
Add a helper function gimp_dock_window_should_add_to_recent() which
properly handles the toolbox with regards to what dock windows that
should be added to the list of recently closed docks.
Since the order of docks in a dock window is arbitrary, it can never
be correct to only care about the first dock. Remove
gimp_dock_window_get_dock() and correct that code that made use of
it. (The function itself was introduced when there could only be one
dock per dock window.)
Move toolbox special casing into
gimp_dialog_factory_dialog_new_internal() and on the fly fix problems
with double toolboxes appearing and sometimes not appearing.
- in GimpText, make "text" and "markup" mutually exclusive, so that
whenever one is set to non-NULL, the other is cleared automatically.
- add gimp_text_buffer_has_markup() which returns TRUE if any char
in the buffer is tagged.
- in the text tool, only set "markup" on the text proxy if there is
actually markup in the buffer, and set "text" otherwise.
This way we don't push "text" *and* "markup" undos on each keystroke,
and undo compression works the way it did before.
In the drop callbacks, don't check if the GimpContainerView's container
contains the dropped item, it might be in a sub-container. Instead,
simply checking if the GimpContainerView knows the item is sufficient
(and also much simpler than a recursive container serach).
Instead, keep a list of tags to explicitely remove around (the list of
unchecked toggles), and remove only these tags, so the tags that have
no widget in the UI are not affected by the insert_tags logic.
Add gimp_text_buffer_get_iter_at_index() which does the reverse thing
than the already existing function gimp_text_buffer_get_iter_index().
Use the new function when cursor-navigation lines. Add "gboolean
layout_index" to both functions, which if TRUE indicates that the
passed in/out index is an index into the PangoLayout's content rather
than the text buffer's. When dealing with layout indices, take into
account the additional characters we insert into the serialized markup
(and thus the layout) for each character that is tagged with spacing.
Instead of including dialogs/dialogs.h everywhere, introduce
gimp_dialog_factory_get_singleton(). The dialog factory singleton is
still initialized by dialogs.c though.
Right now the assumption is that we never will have another dialog
factory instance around. There were so many problems before when we
had four of them, so let's just keep one of them around.
because it breaks the invariant that the pango layout used for
navigating in the on-canvas editor must be a 1:1 view on the text
buffer used for editing. Will have to fix that somehow...
We only have one dialog factory now, and
gimp_dialog_factory_from_name() doesn't provide compile-time type
safety, so use global_dialog_factory directly instead.
The copy doesn't do anything yet, but this will enable us to do
transformations on the buffer contents before turning them into
markup, and the other way around.
because we will soon use temporary buffers to turn stuff into markup
and back, and these temporary buffers won't have their tags registered
like the original GimpTextBuffer does.
Use gtk_text_buffer_begin_user_action() and end_user_action() to group
all text buffer operations triggered by a single editing operation.
Connect to the buffer's "end-user-action" signal instead of to
"changed", "apply-tag" and "remove-tag" separately, so we only update
the text proxy once per user editing.
Add a list of available baseline tags to GimpTextBuffer and
automatically create baseline tags as needed. They get serialized as
<span rise="value">, so add attribute and value parameters to the
buffer's tag_to_name() and name_to_tag() functions. Properly managing
the rise's amount is a TODO, currently each keystroke changes the
baseline by 1024 pango units, which might be whatever depending on the
output grid.
instead of using the toggles only to change the style of selected text.
Introduces a list of "insert tags" in GimpTextBuffer that is applied
on newly inserted text if it exists. Clear the list on each content
or cursor/selection change, so we always display wthe style at the
cursor unless the buttons were clicked explicitely.
When turning overlapping tags into a strictly nested markup structure,
make sure we don't treat tags that are ending at an iter like tags
that were only closed because overlapping spans don't exist in markup.
Chew on this sentence a bit, it took ages to write it.
- keep around tags for styles in GimpTextBuffer. For now only bold,
italic, underline and strikethrough.
- add GimpTextStyleEditor, a widget which allows setting tags on
a GimpTextBuffer's selection.
- add serialize/deserialize code to/from pango markup using
GtkTextBuffer's rich text (de)serialization infrastructure.
Doesn't produce or handle <span> yet.
Pull all text buffer utility functions as methods and use
GimpTextBuffer all over the place instead of GtkTextBuffer.
Some actually usefuly features coming soon...
and get rid of the brainfuck idea that app/ has to use _gimp_unit_foo()
functions, passing a gimp pointer. Instead, simply use the libgimpbase
API all over the place. Should we ever allow more than one gimp instance,
they will simply have to share one unit database.
Add Windows→Hide docks menu item. We don't remove the hardcoding of
having Tab trigger it though, because gtk_accelerator_valid() returns
FALSE for GDK_tab. This means that if the user changes keyboard
shortcut for the menu item, both the user shortcut and the hardcoded
shortcut will work. We remove gimp_dialog_factories_toggle() and make
clients activate the action instead to toggle dock visibility.
Make sure that after we have set GTK_WIN_POS_MOUSE on a dialog created
with the dialog factory, it is eventually reset. Also remove the only
occurance of the DEBUG_FACTORY define.
and change the dialog from a editor of the display's devices to an
editor of all devices of all displays known to GIMP, regardless
whether currently plugged or just remembered in devicerc. will need to
distinguish them in the next step...
Add functions that are similar to the "device-added" and
"device-removed" of GdkDeviceManager in the XI2 branch. Add "device"
and "display" properties to GimpDeviceInfp and distunguish between
creating device info objects from scratch for never-seen devices, and
setting a GdkDevice on them when a previously known device gets
plugged in.
Added two new widgets, GimpDeviceInfoEditor, which is an editor/view
widget for GimpDeviceInfo, and GimpDeviceEditor, which is an editor
widget for all devices. Both are pretty much ugly right now and look a
lot like the old GtkInputDialog, but are at least internally cleaned
up and easily changable code and ui wise. Consider this a completely
intermediate state.
Also cleaned up GimpDeviceInfo so it's possible to have a proper
view on it, and did the needed changes to the preferences dialog
to use the new stuff.
Add gimp_image_new_from_drawable(), from_component() and from_pixbuf()
and remove that duplicated code from gimptoolbox-dnd.c and
gimpdisplayshell-dnd.c
because they are "new" only once and then never again. Instead, simply
call new stuff "Layer", "Channel" and "Path", either by passing that
string explicitely, or by passing NULL so their class' default name
will be used.
'Pixel dimensions' can be misinterpreted with the size of a pixel, so
use 'size in pixels' instead. This is consistent with e.g. the Image
Scale dialog which talks about 'image size'.
In order to make a clear separation between the core modules and the
UI modules, move the necessary enums from display-enums.h and
widgets-enums.h to config-enums.h and the files
gimpdisplayoptions.[ch] from the display to the config module. This
removes the config -> display dependency.
This change has three main benefits
* It lets us remove includes of display files from the config module
* We don't have to link gimp-console and test-config with a subset of
object files from the display module
* It is reflected in devel-docs/gimp-module-dependencies.svg that the
application is made up of core modules and UI modules and that no
core module depends on any UI module
Session files from GIMP 2.6 don't need to have docks in the toolbox
top-level. Don't crash on that, instead add a "gimp-toolbox" dock
during sessionrc parsing.
Get rid of 'global_toolbox_factory' and manage everything dock-related
with 'global_dock_factory'. The whole of 'global_toolbox_factory' was
a big special-case and getting rid of it makes it easier to extend the
session management with e.g. single-window mode dock functionality.
To get rid of 'global_toolbox_factory' we, roughly, have to
* Replace 'global_toolbox_factory' with 'global_dock_factory'
everywhere. We can also get rid of lots of code that did special
things for the "toolbox" factory.
* Make the use or interaction with the toolbox explicit in some
places. For example, a function gimp_dock_window_has_toolbox() has
been introduced.
* Make GimpSessionInfoDock have an 'identifier' parameter so we can
differentiate between the "gimp-dock" and "gimp-toolbox" dock
types.
Rename back global_dock_window_factory to
global_dock_factory. Renaming to global_dock_window_factory was done
under the assumption that there would be a separate factory that would
create non-toplevel dockables, but I don't expect this to happen in
the forseeable future.
Let dock windows have proper GimpDialogFactory entries. This allows us
to get rid of a lot of ugly mostly duplicated code. This also makes us
ready the merge the dock window and toolbox factories which will soon
be done. A few things should be noted:
* We adjust the wrap box aspect ratio in the toolbox to avoid having
the toolbox dock window explode
* We make sure that we still can handle sessionrc files from GIMP 2.6
and older
Instead of having one dock constructor per dialog factory, put entries
for the normal dock and the toolbox dock in the dock window
factory. To do this we also need to merge the dock and normal dialog
constructors into one function protptype.
This takes us one step closer to be able to merge the
global_dock_window_factory and the global_toolbox_factory into one.
The long term goal: Support multi-column dock windows with one of the
docks being the toolbox. In this situation we can't have the toolbox
dock created by a separate dialog factory, that is too messy.
Instead of having gimp_dialog_factory_set_put_in_dockables() with all
the cruft that leads to we can use the 'dockable' member on
GimpDialogFactoryEntry. This is a general strategy that the code base
is being moved in: try to keep information per-entry rather than
per-factory.
Change gimp_dialog_factory_set_constructor() to
gimp_dialog_factory_set_put_in_dockables() order to narrow the
interface a bit. We can make both
gimp_dialog_factory_set_put_in_dockables() and the
GimpDialogConstructor typedef internal this way.
The main reason we do this is because we want to get rid of a
dependency on factory->p->new_dock_func. Eventually we want to
construct docks just like we construct other widgets in the factory,
so new_dock_func will be removed.
Also improve readability of code such as making it explicit that
gimp_dialog_factory_put_in_dockable_constructor() is just an extended
version of gimp_dialog_factory_default_constructor().
In order to let tests run against the source dir, allow them to
override the menus directory. Add utility functions for this and
adjust gimpuimanager.c accordingly.
Add "dialog-factory", "ui-manager" properties to GimpDockColumns and
let GimpDock look for these before trying to look for a dock window
which does not exist in single-window mode.
Add and use gimp_dock_columns_new() and add a GimpContext property to
GimpDockColumns. Also move the widget construction from _init() to
_constructor() in GimpDockWindow so we have a context object to pass
to gimp_dock_columns_new().
When moving dockables from a dock window to an image window, they need
to start listening to the user context. So update the dockables with
the new context when we switch window mode.
Don't fail when checking for availability of buffers in
gimp_view_render_to_surface(). The buffers will be gone when quitting
GIMP while in s-w-m and we don't want to print a warning every time
that happens.
Derive GimpTranslationStore from GimpLanguageStore. It lists the
installed GIMP translations. Also sort the list alphabetically
instead of relying on the XML file being sorted.
When quitting GIMP while in single-window mode and the widget
hierarchies are cleaned up, prevent a tab widget from being
constructed so we don't get any annoying warnings due to failing to
look up a context.
