dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Did a global s/qmask/quick-mask/: 

2005-09-19  Michael Natterer  <mitch@gimp.org>

	Did a global s/qmask/quick-mask/:

	* app/actions/qmask-actions.[ch]
	* app/actions/qmask-commands.[ch]
	* app/core/gimpimage-qmask.[ch]
	* menus/qmask-menu.xml
	* themes/Default/images/stock-qmask-off-16.png
	* themes/Default/images/stock-qmask-on-16.png: removed.

	* app/actions/quick-mask-actions.[ch]
	* app/actions/quick-mask-commands.[ch]
	* app/core/gimpimage-quick-mask.[ch]
	* menus/quick-mask-menu.xml
	* themes/Default/images/stock-quick-mask-off-16.png
	* themes/Default/images/stock-quick-mask-on-16.png: added.

	* app/actions/Makefile.am
	* app/actions/actions.c
	* app/core/Makefile.am
	* app/core/core-enums.[ch]
	* app/core/gimpchannel.c
	* app/core/gimpimage-duplicate.c
	* app/core/gimpimage-undo.c
	* app/core/gimpimage.[ch]
	* app/core/gimpundo.[ch]
	* app/display/gimpdisplayshell-appearance.c
	* app/display/gimpdisplayshell-callbacks.[ch]
	* app/display/gimpdisplayshell-handlers.c
	* app/display/gimpdisplayshell.[ch]
	* app/menus/menus.c
	* app/widgets/gimphelp-ids.h
	* libgimpwidgets/gimpstock.[ch]
	* menus/Makefile.am
	* menus/image-menu.xml.in
	* themes/Default/images/Makefile.am: changed accordingly.
This commit is contained in:
Michael Natterer 2005-09-19 12:44:06 +00:00 committed by Michael Natterer
parent 7f95ed5360
commit 1adf3d71af
42 changed files with 346 additions and 860 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
ChangeLog
View File

@ -1,3 +1,41 @@
2005-09-19 Michael Natterer <mitch@gimp.org>
Did a global s/qmask/quick-mask/:
* app/actions/qmask-actions.[ch]
* app/actions/qmask-commands.[ch]
* app/core/gimpimage-qmask.[ch]
* menus/qmask-menu.xml
* themes/Default/images/stock-qmask-off-16.png
* themes/Default/images/stock-qmask-on-16.png: removed.
* app/actions/quick-mask-actions.[ch]
* app/actions/quick-mask-commands.[ch]
* app/core/gimpimage-quick-mask.[ch]
* menus/quick-mask-menu.xml
* themes/Default/images/stock-quick-mask-off-16.png
* themes/Default/images/stock-quick-mask-on-16.png: added.
* app/actions/Makefile.am
* app/actions/actions.c
* app/core/Makefile.am
* app/core/core-enums.[ch]
* app/core/gimpchannel.c
* app/core/gimpimage-duplicate.c
* app/core/gimpimage-undo.c
* app/core/gimpimage.[ch]
* app/core/gimpundo.[ch]
* app/display/gimpdisplayshell-appearance.c
* app/display/gimpdisplayshell-callbacks.[ch]
* app/display/gimpdisplayshell-handlers.c
* app/display/gimpdisplayshell.[ch]
* app/menus/menus.c
* app/widgets/gimphelp-ids.h
* libgimpwidgets/gimpstock.[ch]
* menus/Makefile.am
* menus/image-menu.xml.in
* themes/Default/images/Makefile.am: changed accordingly.
2005-09-19 Sven Neumann <sven@gimp.org> 2005-09-19 Sven Neumann <sven@gimp.org>
* app/core/gimpimagefile.c (gimp_imagefile_get_new_pixbuf): use * app/core/gimpimagefile.c (gimp_imagefile_get_new_pixbuf): use

8
app/actions/Makefile.am
View File

@ -109,10 +109,10 @@ libappactions_a_SOURCES = \
plug-in-actions.h \ plug-in-actions.h \
plug-in-commands.c \ plug-in-commands.c \
plug-in-commands.h \ plug-in-commands.h \
qmask-actions.c \ quick-mask-actions.c \
qmask-actions.h \ quick-mask-actions.h \
qmask-commands.c \ quick-mask-commands.c \
qmask-commands.h \ quick-mask-commands.h \
sample-point-editor-actions.c \ sample-point-editor-actions.c \
sample-point-editor-actions.h \ sample-point-editor-actions.h \
sample-point-editor-commands.c \ sample-point-editor-commands.c \

8
app/actions/actions.c
View File

@ -72,7 +72,7 @@
#include "palettes-actions.h" #include "palettes-actions.h"
#include "patterns-actions.h" #include "patterns-actions.h"
#include "plug-in-actions.h" #include "plug-in-actions.h"
#include "qmask-actions.h" #include "quick-mask-actions.h"
#include "sample-point-editor-actions.h" #include "sample-point-editor-actions.h"
#include "select-actions.h" #include "select-actions.h"
#include "templates-actions.h" #include "templates-actions.h"
@ -172,9 +172,9 @@ static GimpActionFactoryEntry action_groups[] =
{ "plug-in", N_("Plug-Ins"), GIMP_STOCK_PLUGIN, { "plug-in", N_("Plug-Ins"), GIMP_STOCK_PLUGIN,
plug_in_actions_setup, plug_in_actions_setup,
plug_in_actions_update }, plug_in_actions_update },
{ "qmask", N_("Quick Mask"), GIMP_STOCK_QMASK_ON, { "quick-mask", N_("Quick Mask"), GIMP_STOCK_QUICK_MASK_ON,
qmask_actions_setup, quick_mask_actions_setup,
qmask_actions_update }, quick_mask_actions_update },
{ "sample-point-editor", N_("Sample Points"), GIMP_STOCK_SAMPLE_POINT, { "sample-point-editor", N_("Sample Points"), GIMP_STOCK_SAMPLE_POINT,
sample_point_editor_actions_setup, sample_point_editor_actions_setup,
sample_point_editor_actions_update }, sample_point_editor_actions_update },

124
app/actions/qmask-actions.c
View File

@ -1,124 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gtk/gtk.h>
#include "libgimpwidgets/gimpwidgets.h"
#include "actions-types.h"
#include "core/gimpimage.h"
#include "widgets/gimpactiongroup.h"
#include "widgets/gimphelp-ids.h"
#include "actions.h"
#include "qmask-actions.h"
#include "qmask-commands.h"
#include "gimp-intl.h"
static GimpActionEntry qmask_actions[] =
{
{ "qmask-popup", NULL,
N_("Quick Mask Menu"), NULL, NULL, NULL,
GIMP_HELP_QMASK },
{ "qmask-configure", NULL,
N_("_Configure Color and Opacity..."), NULL, NULL,
G_CALLBACK (qmask_configure_cmd_callback),
GIMP_HELP_QMASK_EDIT }
};
static GimpToggleActionEntry qmask_toggle_actions[] =
{
{ "qmask-toggle", GIMP_STOCK_QMASK_ON,
N_("Toggle _Quick Mask"), "<shift>Q", NULL,
G_CALLBACK (qmask_toggle_cmd_callback),
FALSE,
GIMP_HELP_QMASK_TOGGLE }
};
static GimpRadioActionEntry qmask_invert_actions[] =
{
{ "qmask-invert-on", NULL,
N_("Mask _Selected Areas"), NULL, NULL,
TRUE,
GIMP_HELP_QMASK_INVERT },
{ "qmask-invert-off", NULL,
N_("Mask _Unselected Areas"), NULL, NULL,
FALSE,
GIMP_HELP_QMASK_INVERT }
};
void
qmask_actions_setup (GimpActionGroup *group)
{
gimp_action_group_add_actions (group,
qmask_actions,
G_N_ELEMENTS (qmask_actions));
gimp_action_group_add_toggle_actions (group,
qmask_toggle_actions,
G_N_ELEMENTS (qmask_toggle_actions));
gimp_action_group_add_radio_actions (group,
qmask_invert_actions,
G_N_ELEMENTS (qmask_invert_actions),
FALSE,
G_CALLBACK (qmask_invert_cmd_callback));
}
void
qmask_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpImage *gimage = action_data_get_image (data);
#define SET_SENSITIVE(action,sensitive) \
gimp_action_group_set_action_sensitive (group, action, (sensitive) != 0)
#define SET_ACTIVE(action,active) \
gimp_action_group_set_action_active (group, action, (active) != 0)
#define SET_COLOR(action,color) \
gimp_action_group_set_action_color (group, action, (color), FALSE)
SET_SENSITIVE ("qmask-toggle", gimage);
SET_ACTIVE ("qmask-toggle", gimage && gimage->qmask_state);
SET_SENSITIVE ("qmask-invert-on", gimage);
SET_SENSITIVE ("qmask-invert-off", gimage);
if (gimage && gimage->qmask_inverted)
SET_ACTIVE ("qmask-invert-on", TRUE);
else
SET_ACTIVE ("qmask-invert-off", TRUE);
SET_SENSITIVE ("qmask-configure", gimage);
if (gimage)
SET_COLOR ("qmask-configure", &gimage->qmask_color);
#undef SET_SENSITIVE
#undef SET_ACTIVE
#undef SET_COLOR
}

28
app/actions/qmask-actions.h
View File

@ -1,28 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __QMASK_ACTIONS_H__
#define __QMASK_ACTIONS_H__
void qmask_actions_setup (GimpActionGroup *group);
void qmask_actions_update (GimpActionGroup *group,
gpointer data);
#endif /* __QMASK_ACTIONS_H__ */

148
app/actions/qmask-commands.c
View File

@ -1,148 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gtk/gtk.h>
#include "libgimpcolor/gimpcolor.h"
#include "libgimpwidgets/gimpwidgets.h"
#include "actions-types.h"
#include "core/gimp.h"
#include "core/gimpchannel.h"
#include "core/gimpimage.h"
#include "core/gimpimage-qmask.h"
#include "widgets/gimphelp-ids.h"
#include "dialogs/channel-options-dialog.h"
#include "actions.h"
#include "qmask-commands.h"
#include "gimp-intl.h"
/* local function prototypes */
static void qmask_configure_response (GtkWidget *widget,
gint response_id,
ChannelOptionsDialog *options);
/* public functionss */
void
qmask_toggle_cmd_callback (GtkAction *action,
gpointer data)
{
GimpImage *gimage;
gboolean active;
return_if_no_image (gimage, data);
active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
if (active != gimp_image_get_qmask_state (gimage))
{
gimp_image_set_qmask_state (gimage, active);
gimp_image_flush (gimage);
}
}
void
qmask_invert_cmd_callback (GtkAction *action,
GtkAction *current,
gpointer data)
{
GimpImage *gimage;
gint value;
return_if_no_image (gimage, data);
value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));
if (value != gimage->qmask_inverted)
{
gimp_image_qmask_invert (gimage);
gimp_image_flush (gimage);
}
}
void
qmask_configure_cmd_callback (GtkAction *action,
gpointer data)
{
ChannelOptionsDialog *options;
GimpImage *gimage;
GtkWidget *widget;
GimpRGB color;
return_if_no_image (gimage, data);
return_if_no_widget (widget, data);
gimp_image_get_qmask_color (gimage, &color);
options = channel_options_dialog_new (gimage,
action_data_get_context (data),
NULL,
widget,
&color,
NULL,
_("Quick Mask Attributes"),
"gimp-qmask-edit",
GIMP_STOCK_QMASK_ON,
_("Edit Quick Mask Attributes"),
GIMP_HELP_QMASK_EDIT,
_("Edit Quick Mask Color"),
_("_Mask opacity:"),
FALSE);
g_signal_connect (options->dialog, "response",
G_CALLBACK (qmask_configure_response),
options);
gtk_widget_show (options->dialog);
}
/* private functions */
static void
qmask_configure_response (GtkWidget *widget,
gint response_id,
ChannelOptionsDialog *options)
{
if (response_id == GTK_RESPONSE_OK)
{
GimpRGB old_color;
GimpRGB new_color;
gimp_image_get_qmask_color (options->gimage, &old_color);
gimp_color_button_get_color (GIMP_COLOR_BUTTON (options->color_panel),
&new_color);
if (gimp_rgba_distance (&old_color, &new_color) > 0.0001)
{
gimp_image_set_qmask_color (options->gimage, &new_color);
gimp_image_flush (options->gimage);
}
}
gtk_widget_destroy (options->dialog);
}

32
app/actions/qmask-commands.h
View File

@ -1,32 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __QMASK_COMMANDS_H__
#define __QMASK_COMMANDS_H__
void qmask_toggle_cmd_callback (GtkAction *action,
gpointer data);
void qmask_invert_cmd_callback (GtkAction *action,
GtkAction *current,
gpointer data);
void qmask_configure_cmd_callback (GtkAction *action,
gpointer data);
#endif /* __QMASK_COMMANDS_H__ */

72
app/actions/quick-mask-actions.c
View File

@ -30,68 +30,68 @@
#include "widgets/gimphelp-ids.h" #include "widgets/gimphelp-ids.h"
#include "actions.h" #include "actions.h"
#include "qmask-actions.h" #include "quick-mask-actions.h"
#include "qmask-commands.h" #include "quick-mask-commands.h"
#include "gimp-intl.h" #include "gimp-intl.h"
static GimpActionEntry qmask_actions[] = static GimpActionEntry quick_mask_actions[] =
{ {
{ "qmask-popup", NULL, { "quick-mask-popup", NULL,
N_("Quick Mask Menu"), NULL, NULL, NULL, N_("Quick Mask Menu"), NULL, NULL, NULL,
GIMP_HELP_QMASK }, GIMP_HELP_QUICK_MASK },
{ "qmask-configure", NULL, { "quick-mask-configure", NULL,
N_("_Configure Color and Opacity..."), NULL, NULL, N_("_Configure Color and Opacity..."), NULL, NULL,
G_CALLBACK (qmask_configure_cmd_callback), G_CALLBACK (quick_mask_configure_cmd_callback),
GIMP_HELP_QMASK_EDIT } GIMP_HELP_QUICK_MASK_EDIT }
}; };
static GimpToggleActionEntry qmask_toggle_actions[] = static GimpToggleActionEntry quick_mask_toggle_actions[] =
{ {
{ "qmask-toggle", GIMP_STOCK_QMASK_ON, { "quick-mask-toggle", GIMP_STOCK_QUICK_MASK_ON,
N_("Toggle _Quick Mask"), "<shift>Q", NULL, N_("Toggle _Quick Mask"), "<shift>Q", NULL,
G_CALLBACK (qmask_toggle_cmd_callback), G_CALLBACK (quick_mask_toggle_cmd_callback),
FALSE, FALSE,
GIMP_HELP_QMASK_TOGGLE } GIMP_HELP_QUICK_MASK_TOGGLE }
}; };
static GimpRadioActionEntry qmask_invert_actions[] = static GimpRadioActionEntry quick_mask_invert_actions[] =
{ {
{ "qmask-invert-on", NULL, { "quick-mask-invert-on", NULL,
N_("Mask _Selected Areas"), NULL, NULL, N_("Mask _Selected Areas"), NULL, NULL,
TRUE, TRUE,
GIMP_HELP_QMASK_INVERT }, GIMP_HELP_QUICK_MASK_INVERT },
{ "qmask-invert-off", NULL, { "quick-mask-invert-off", NULL,
N_("Mask _Unselected Areas"), NULL, NULL, N_("Mask _Unselected Areas"), NULL, NULL,
FALSE, FALSE,
GIMP_HELP_QMASK_INVERT } GIMP_HELP_QUICK_MASK_INVERT }
}; };
void void
qmask_actions_setup (GimpActionGroup *group) quick_mask_actions_setup (GimpActionGroup *group)
{ {
gimp_action_group_add_actions (group, gimp_action_group_add_actions (group,
qmask_actions, quick_mask_actions,
G_N_ELEMENTS (qmask_actions)); G_N_ELEMENTS (quick_mask_actions));
gimp_action_group_add_toggle_actions (group, gimp_action_group_add_toggle_actions (group,
qmask_toggle_actions, quick_mask_toggle_actions,
G_N_ELEMENTS (qmask_toggle_actions)); G_N_ELEMENTS (quick_mask_toggle_actions));
gimp_action_group_add_radio_actions (group, gimp_action_group_add_radio_actions (group,
qmask_invert_actions, quick_mask_invert_actions,
G_N_ELEMENTS (qmask_invert_actions), G_N_ELEMENTS (quick_mask_invert_actions),
FALSE, FALSE,
G_CALLBACK (qmask_invert_cmd_callback)); G_CALLBACK (quick_mask_invert_cmd_callback));
} }
void void
qmask_actions_update (GimpActionGroup *group, quick_mask_actions_update (GimpActionGroup *group,
gpointer data) gpointer data)
{ {
GimpImage *gimage = action_data_get_image (data); GimpImage *gimage = action_data_get_image (data);
@ -102,21 +102,21 @@ qmask_actions_update (GimpActionGroup *group,
#define SET_COLOR(action,color) \ #define SET_COLOR(action,color) \
gimp_action_group_set_action_color (group, action, (color), FALSE) gimp_action_group_set_action_color (group, action, (color), FALSE)
SET_SENSITIVE ("qmask-toggle", gimage); SET_SENSITIVE ("quick-mask-toggle", gimage);
SET_ACTIVE ("qmask-toggle", gimage && gimage->qmask_state); SET_ACTIVE ("quick-mask-toggle", gimage && gimage->quick_mask_state);
SET_SENSITIVE ("qmask-invert-on", gimage); SET_SENSITIVE ("quick-mask-invert-on", gimage);
SET_SENSITIVE ("qmask-invert-off", gimage); SET_SENSITIVE ("quick-mask-invert-off", gimage);
if (gimage && gimage->qmask_inverted) if (gimage && gimage->quick_mask_inverted)
SET_ACTIVE ("qmask-invert-on", TRUE); SET_ACTIVE ("quick-mask-invert-on", TRUE);
else else
SET_ACTIVE ("qmask-invert-off", TRUE); SET_ACTIVE ("quick-mask-invert-off", TRUE);
SET_SENSITIVE ("qmask-configure", gimage); SET_SENSITIVE ("quick-mask-configure", gimage);
if (gimage) if (gimage)
SET_COLOR ("qmask-configure", &gimage->qmask_color); SET_COLOR ("quick-mask-configure", &gimage->quick_mask_color);
#undef SET_SENSITIVE #undef SET_SENSITIVE
#undef SET_ACTIVE #undef SET_ACTIVE

12
app/actions/quick-mask-actions.h
View File

@ -16,13 +16,13 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/ */
#ifndef __QMASK_ACTIONS_H__ #ifndef __QUICK_MASK_ACTIONS_H__
#define __QMASK_ACTIONS_H__ #define __QUICK_MASK_ACTIONS_H__
void qmask_actions_setup (GimpActionGroup *group); void quick_mask_actions_setup (GimpActionGroup *group);
void qmask_actions_update (GimpActionGroup *group, void quick_mask_actions_update (GimpActionGroup *group,
gpointer data); gpointer data);
#endif /* __QMASK_ACTIONS_H__ */ #endif /* __QUICK_MASK_ACTIONS_H__ */

52
app/actions/quick-mask-commands.c
View File

@ -28,30 +28,30 @@
#include "core/gimp.h" #include "core/gimp.h"
#include "core/gimpchannel.h" #include "core/gimpchannel.h"
#include "core/gimpimage.h" #include "core/gimpimage.h"
#include "core/gimpimage-qmask.h" #include "core/gimpimage-quick-mask.h"
#include "widgets/gimphelp-ids.h" #include "widgets/gimphelp-ids.h"
#include "dialogs/channel-options-dialog.h" #include "dialogs/channel-options-dialog.h"
#include "actions.h" #include "actions.h"
#include "qmask-commands.h" #include "quick-mask-commands.h"
#include "gimp-intl.h" #include "gimp-intl.h"
/* local function prototypes */ /* local function prototypes */
static void qmask_configure_response (GtkWidget *widget, static void quick_mask_configure_response (GtkWidget *widget,
gint response_id, gint response_id,
ChannelOptionsDialog *options); ChannelOptionsDialog *options);
/* public functionss */ /* public functionss */
void void
qmask_toggle_cmd_callback (GtkAction *action, quick_mask_toggle_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
gboolean active; gboolean active;
@ -59,17 +59,17 @@ qmask_toggle_cmd_callback (GtkAction *action,
active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)); active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
if (active != gimp_image_get_qmask_state (gimage)) if (active != gimp_image_get_quick_mask_state (gimage))
{ {
gimp_image_set_qmask_state (gimage, active); gimp_image_set_quick_mask_state (gimage, active);
gimp_image_flush (gimage); gimp_image_flush (gimage);
} }
} }
void void
qmask_invert_cmd_callback (GtkAction *action, quick_mask_invert_cmd_callback (GtkAction *action,
GtkAction *current, GtkAction *current,
gpointer data) gpointer data)
{ {
GimpImage *gimage; GimpImage *gimage;
gint value; gint value;
@ -77,16 +77,16 @@ qmask_invert_cmd_callback (GtkAction *action,
value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action)); value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));
if (value != gimage->qmask_inverted) if (value != gimage->quick_mask_inverted)
{ {
gimp_image_qmask_invert (gimage); gimp_image_quick_mask_invert (gimage);
gimp_image_flush (gimage); gimp_image_flush (gimage);
} }
} }
void void
qmask_configure_cmd_callback (GtkAction *action, quick_mask_configure_cmd_callback (GtkAction *action,
gpointer data) gpointer data)
{ {
ChannelOptionsDialog *options; ChannelOptionsDialog *options;
GimpImage *gimage; GimpImage *gimage;
@ -95,7 +95,7 @@ qmask_configure_cmd_callback (GtkAction *action,
return_if_no_image (gimage, data); return_if_no_image (gimage, data);
return_if_no_widget (widget, data); return_if_no_widget (widget, data);
gimp_image_get_qmask_color (gimage, &color); gimp_image_get_quick_mask_color (gimage, &color);
options = channel_options_dialog_new (gimage, options = channel_options_dialog_new (gimage,
action_data_get_context (data), action_data_get_context (data),
@ -104,16 +104,16 @@ qmask_configure_cmd_callback (GtkAction *action,
&color, &color,
NULL, NULL,
_("Quick Mask Attributes"), _("Quick Mask Attributes"),
"gimp-qmask-edit", "gimp-quick-mask-edit",
GIMP_STOCK_QMASK_ON, GIMP_STOCK_QUICK_MASK_ON,
_("Edit Quick Mask Attributes"), _("Edit Quick Mask Attributes"),
GIMP_HELP_QMASK_EDIT, GIMP_HELP_QUICK_MASK_EDIT,
_("Edit Quick Mask Color"), _("Edit Quick Mask Color"),
_("_Mask opacity:"), _("_Mask opacity:"),
FALSE); FALSE);
g_signal_connect (options->dialog, "response", g_signal_connect (options->dialog, "response",
G_CALLBACK (qmask_configure_response), G_CALLBACK (quick_mask_configure_response),
options); options);
gtk_widget_show (options->dialog); gtk_widget_show (options->dialog);
@ -123,22 +123,22 @@ qmask_configure_cmd_callback (GtkAction *action,
/* private functions */ /* private functions */
static void static void
qmask_configure_response (GtkWidget *widget, quick_mask_configure_response (GtkWidget *widget,
gint response_id, gint response_id,
ChannelOptionsDialog *options) ChannelOptionsDialog *options)
{ {
if (response_id == GTK_RESPONSE_OK) if (response_id == GTK_RESPONSE_OK)
{ {
GimpRGB old_color; GimpRGB old_color;
GimpRGB new_color; GimpRGB new_color;
gimp_image_get_qmask_color (options->gimage, &old_color); gimp_image_get_quick_mask_color (options->gimage, &old_color);
gimp_color_button_get_color (GIMP_COLOR_BUTTON (options->color_panel), gimp_color_button_get_color (GIMP_COLOR_BUTTON (options->color_panel),
&new_color); &new_color);
if (gimp_rgba_distance (&old_color, &new_color) > 0.0001) if (gimp_rgba_distance (&old_color, &new_color) > 0.0001)
{ {
gimp_image_set_qmask_color (options->gimage, &new_color); gimp_image_set_quick_mask_color (options->gimage, &new_color);
gimp_image_flush (options->gimage); gimp_image_flush (options->gimage);
} }

20
app/actions/quick-mask-commands.h
View File

@ -16,17 +16,17 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/ */
#ifndef __QMASK_COMMANDS_H__ #ifndef __QUICK_MASK_COMMANDS_H__
#define __QMASK_COMMANDS_H__ #define __QUICK_MASK_COMMANDS_H__
void qmask_toggle_cmd_callback (GtkAction *action, void quick_mask_toggle_cmd_callback (GtkAction *action,
gpointer data); gpointer data);
void qmask_invert_cmd_callback (GtkAction *action, void quick_mask_invert_cmd_callback (GtkAction *action,
GtkAction *current, GtkAction *current,
gpointer data); gpointer data);
void qmask_configure_cmd_callback (GtkAction *action, void quick_mask_configure_cmd_callback (GtkAction *action,
gpointer data); gpointer data);
#endif /* __QMASK_COMMANDS_H__ */ #endif /* __QUICK_MASK_COMMANDS_H__ */

4
app/core/Makefile.am
View File

@ -147,8 +147,8 @@ libappcore_a_sources = \
gimpimage-pick-color.h \ gimpimage-pick-color.h \
gimpimage-preview.c \ gimpimage-preview.c \
gimpimage-preview.h \ gimpimage-preview.h \
gimpimage-qmask.c \ gimpimage-quick-mask.c \
gimpimage-qmask.h \ gimpimage-quick-mask.h \
gimpimage-resize.c \ gimpimage-resize.c \
gimpimage-resize.h \ gimpimage-resize.h \
gimpimage-rotate.c \ gimpimage-rotate.c \

4
app/core/core-enums.c
View File

@ -725,7 +725,7 @@ gimp_undo_type_get_type (void)
{ GIMP_UNDO_GROUP_IMAGE_ITEM_REMOVE, "GIMP_UNDO_GROUP_IMAGE_ITEM_REMOVE", "group-image-item-remove" }, { GIMP_UNDO_GROUP_IMAGE_ITEM_REMOVE, "GIMP_UNDO_GROUP_IMAGE_ITEM_REMOVE", "group-image-item-remove" },
{ GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE, "GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE", "group-image-layers-merge" }, { GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE, "GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE", "group-image-layers-merge" },
{ GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE, "GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE", "group-image-vectors-merge" }, { GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE, "GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE", "group-image-vectors-merge" },
{ GIMP_UNDO_GROUP_IMAGE_QMASK, "GIMP_UNDO_GROUP_IMAGE_QMASK", "group-image-qmask" }, { GIMP_UNDO_GROUP_IMAGE_QUICK_MASK, "GIMP_UNDO_GROUP_IMAGE_QUICK_MASK", "group-image-quick-mask" },
{ GIMP_UNDO_GROUP_IMAGE_GUIDE, "GIMP_UNDO_GROUP_IMAGE_GUIDE", "group-image-guide" }, { GIMP_UNDO_GROUP_IMAGE_GUIDE, "GIMP_UNDO_GROUP_IMAGE_GUIDE", "group-image-guide" },
{ GIMP_UNDO_GROUP_IMAGE_GRID, "GIMP_UNDO_GROUP_IMAGE_GRID", "group-image-grid" }, { GIMP_UNDO_GROUP_IMAGE_GRID, "GIMP_UNDO_GROUP_IMAGE_GRID", "group-image-grid" },
{ GIMP_UNDO_GROUP_IMAGE_SAMPLE_POINT, "GIMP_UNDO_GROUP_IMAGE_SAMPLE_POINT", "group-image-sample-point" }, { GIMP_UNDO_GROUP_IMAGE_SAMPLE_POINT, "GIMP_UNDO_GROUP_IMAGE_SAMPLE_POINT", "group-image-sample-point" },
@ -812,7 +812,7 @@ gimp_undo_type_get_type (void)
{ GIMP_UNDO_GROUP_IMAGE_ITEM_REMOVE, N_("Remove item"), NULL }, { GIMP_UNDO_GROUP_IMAGE_ITEM_REMOVE, N_("Remove item"), NULL },
{ GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE, N_("Merge layers"), NULL }, { GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE, N_("Merge layers"), NULL },
{ GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE, N_("Merge paths"), NULL }, { GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE, N_("Merge paths"), NULL },
{ GIMP_UNDO_GROUP_IMAGE_QMASK, N_("Quick Mask"), NULL }, { GIMP_UNDO_GROUP_IMAGE_QUICK_MASK, N_("Quick Mask"), NULL },
{ GIMP_UNDO_GROUP_IMAGE_GUIDE, N_("Guide"), NULL }, { GIMP_UNDO_GROUP_IMAGE_GUIDE, N_("Guide"), NULL },
{ GIMP_UNDO_GROUP_IMAGE_GRID, N_("Grid"), NULL }, { GIMP_UNDO_GROUP_IMAGE_GRID, N_("Grid"), NULL },
{ GIMP_UNDO_GROUP_IMAGE_SAMPLE_POINT, N_("Sample Point"), NULL }, { GIMP_UNDO_GROUP_IMAGE_SAMPLE_POINT, N_("Sample Point"), NULL },

2
app/core/core-enums.h
View File

@ -349,7 +349,7 @@ typedef enum /*< pdb-skip >*/
GIMP_UNDO_GROUP_IMAGE_ITEM_REMOVE, /*< desc="Remove item" >*/ GIMP_UNDO_GROUP_IMAGE_ITEM_REMOVE, /*< desc="Remove item" >*/
GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE, /*< desc="Merge layers" >*/ GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE, /*< desc="Merge layers" >*/
GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE,/*< desc="Merge paths" >*/ GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE,/*< desc="Merge paths" >*/
GIMP_UNDO_GROUP_IMAGE_QMASK, /*< desc="Quick Mask" >*/ GIMP_UNDO_GROUP_IMAGE_QUICK_MASK, /*< desc="Quick Mask" >*/
GIMP_UNDO_GROUP_IMAGE_GUIDE, /*< desc="Guide" >*/ GIMP_UNDO_GROUP_IMAGE_GUIDE, /*< desc="Guide" >*/
GIMP_UNDO_GROUP_IMAGE_GRID, /*< desc="Grid" >*/ GIMP_UNDO_GROUP_IMAGE_GRID, /*< desc="Grid" >*/
GIMP_UNDO_GROUP_IMAGE_SAMPLE_POINT, /*< desc="Sample Point" >*/ GIMP_UNDO_GROUP_IMAGE_SAMPLE_POINT, /*< desc="Sample Point" >*/

4
app/core/gimpchannel.c
View File

@ -44,7 +44,7 @@
#include "gimpcontainer.h" #include "gimpcontainer.h"
#include "gimpdrawable-convert.h" #include "gimpdrawable-convert.h"
#include "gimpimage.h" #include "gimpimage.h"
#include "gimpimage-qmask.h" #include "gimpimage-quick-mask.h"
#include "gimpimage-undo.h" #include "gimpimage-undo.h"
#include "gimpimage-undo-push.h" #include "gimpimage-undo-push.h"
#include "gimpchannel.h" #include "gimpchannel.h"
@ -395,7 +395,7 @@ static gchar *
gimp_channel_get_description (GimpViewable *viewable, gimp_channel_get_description (GimpViewable *viewable,
gchar **tooltip) gchar **tooltip)
{ {
if (! strcmp (GIMP_IMAGE_QMASK_NAME, if (! strcmp (GIMP_IMAGE_QUICK_MASK_NAME,
gimp_object_get_name (GIMP_OBJECT (viewable)))) gimp_object_get_name (GIMP_OBJECT (viewable))))
{ {
if (tooltip) if (tooltip)

7
app/core/gimpimage-duplicate.c
View File

@ -251,9 +251,10 @@ gimp_image_duplicate (GimpImage *gimage)
if (gimage->grid) if (gimage->grid)
gimp_image_set_grid (new_gimage, gimage->grid, FALSE); gimp_image_set_grid (new_gimage, gimage->grid, FALSE);
/* Copy the qmask info */ /* Copy the quick mask info */
new_gimage->qmask_state = gimage->qmask_state; new_gimage->quick_mask_state = gimage->quick_mask_state;
new_gimage->qmask_color = gimage->qmask_color; new_gimage->quick_mask_inverted = gimage->quick_mask_inverted;
new_gimage->quick_mask_color = gimage->quick_mask_color;
/* Copy parasites */ /* Copy parasites */
if (gimage->parasites) if (gimage->parasites)

191
app/core/gimpimage-qmask.c
View File

@ -1,191 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <glib-object.h>
#include "libgimpcolor/gimpcolor.h"
#include "core-types.h"
#include "gimp.h"
#include "gimpchannel.h"
#include "gimpimage.h"
#include "gimpimage-qmask.h"
#include "gimpimage-undo.h"
#include "gimpimage-undo-push.h"
#include "gimplayer.h"
#include "gimplayer-floating-sel.h"
#include "gimpselection.h"
#include "gimp-intl.h"
/* public functions */
void
gimp_image_set_qmask_state (GimpImage *gimage,
gboolean qmask_state)
{
GimpChannel *selection;
GimpChannel *mask;
g_return_if_fail (GIMP_IS_IMAGE (gimage));
if (qmask_state == gimage->qmask_state)
return;
/* set image->qmask_state early so we can return early when
* being called recursively
*/
gimage->qmask_state = qmask_state ? TRUE : FALSE;
selection = gimp_image_get_mask (gimage);
mask = gimp_image_get_qmask (gimage);
if (qmask_state)
{
if (! mask)
{
gimp_image_undo_group_start (gimage, GIMP_UNDO_GROUP_IMAGE_QMASK,
_("Enable Quick Mask"));
if (gimp_channel_is_empty (selection))
{
/* if no selection */
GimpLayer *floating_sel = gimp_image_floating_sel (gimage);
if (floating_sel)
floating_sel_to_layer (floating_sel);
mask = gimp_channel_new (gimage,
gimage->width,
gimage->height,
GIMP_IMAGE_QMASK_NAME,
&gimage->qmask_color);
/* Clear the mask */
gimp_channel_clear (mask, NULL, FALSE);
}
else
{
/* if selection */
mask = GIMP_CHANNEL (gimp_item_duplicate (GIMP_ITEM (selection),
GIMP_TYPE_CHANNEL,
FALSE));
/* Clear the selection */
gimp_channel_clear (selection, NULL, TRUE);
gimp_channel_set_color (mask, &gimage->qmask_color, FALSE);
gimp_item_rename (GIMP_ITEM (mask), GIMP_IMAGE_QMASK_NAME);
}
if (gimage->qmask_inverted)
gimp_channel_invert (mask, FALSE);
gimp_image_add_channel (gimage, mask, 0);
gimp_image_undo_group_end (gimage);
}
}
else
{
if (mask)
{
GimpLayer *floating_sel = gimp_image_floating_sel (gimage);
gimp_image_undo_group_start (gimage, GIMP_UNDO_GROUP_IMAGE_QMASK,
_("Disable Quick Mask"));
if (gimage->qmask_inverted)
gimp_channel_invert (mask, TRUE);
if (floating_sel && floating_sel->fs.drawable == GIMP_DRAWABLE (mask))
floating_sel_anchor (floating_sel);
gimp_selection_load (gimp_image_get_mask (gimage), mask);
gimp_image_remove_channel (gimage, mask);
gimp_image_undo_group_end (gimage);
}
}
gimp_image_qmask_changed (gimage);
}
gboolean
gimp_image_get_qmask_state (const GimpImage *gimage)
{
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
return gimage->qmask_state;
}
void
gimp_image_set_qmask_color (GimpImage *gimage,
const GimpRGB *color)
{
GimpChannel *qmask;
g_return_if_fail (GIMP_IS_IMAGE (gimage));
g_return_if_fail (color != NULL);
gimage->qmask_color = *color;
qmask = gimp_image_get_qmask (gimage);
if (qmask)
gimp_channel_set_color (qmask, color, TRUE);
}
void
gimp_image_get_qmask_color (const GimpImage *gimage,
GimpRGB *color)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
g_return_if_fail (color != NULL);
*color = gimage->qmask_color;
}
GimpChannel *
gimp_image_get_qmask (const GimpImage *gimage)
{
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
return gimp_image_get_channel_by_name (gimage, GIMP_IMAGE_QMASK_NAME);
}
void
gimp_image_qmask_invert (GimpImage *gimage)
{
g_return_if_fail (GIMP_IS_IMAGE (gimage));
if (gimage->qmask_state)
{
GimpChannel *qmask = gimp_image_get_qmask (gimage);
if (qmask)
gimp_channel_invert (qmask, TRUE);
}
gimage->qmask_inverted = ! gimage->qmask_inverted;
}

43
app/core/gimpimage-qmask.h
View File

@ -1,43 +0,0 @@
/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GIMP_IMAGE_QMASK_H__
#define __GIMP_IMAGE_QMASK_H__
/* don't change this string, it's used to identify the Quick Mask
* when opening files.
*/
#define GIMP_IMAGE_QMASK_NAME "Qmask"
void gimp_image_set_qmask_state (GimpImage *gimage,
gboolean qmask_state);
gboolean gimp_image_get_qmask_state (const GimpImage *gimage);
void gimp_image_set_qmask_color (GimpImage *gimage,
const GimpRGB *color);
void gimp_image_get_qmask_color (const GimpImage *gimage,
GimpRGB *color);
GimpChannel * gimp_image_get_qmask (const GimpImage *gimage);
void gimp_image_qmask_invert (GimpImage *gimage);
#endif /* __GIMP_IMAGE_QMASK_H__ */

74
app/core/gimpimage-quick-mask.c
View File

@ -27,7 +27,7 @@
#include "gimp.h" #include "gimp.h"
#include "gimpchannel.h" #include "gimpchannel.h"
#include "gimpimage.h" #include "gimpimage.h"
#include "gimpimage-qmask.h" #include "gimpimage-quick-mask.h"
#include "gimpimage-undo.h" #include "gimpimage-undo.h"
#include "gimpimage-undo-push.h" #include "gimpimage-undo-push.h"
#include "gimplayer.h" #include "gimplayer.h"
@ -40,30 +40,30 @@
/* public functions */ /* public functions */
void void
gimp_image_set_qmask_state (GimpImage *gimage, gimp_image_set_quick_mask_state (GimpImage *gimage,
gboolean qmask_state) gboolean quick_mask_state)
{ {
GimpChannel *selection; GimpChannel *selection;
GimpChannel *mask; GimpChannel *mask;
g_return_if_fail (GIMP_IS_IMAGE (gimage)); g_return_if_fail (GIMP_IS_IMAGE (gimage));
if (qmask_state == gimage->qmask_state) if (quick_mask_state == gimage->quick_mask_state)
return; return;
/* set image->qmask_state early so we can return early when /* set image->quick_mask_state early so we can return early when
* being called recursively * being called recursively
*/ */
gimage->qmask_state = qmask_state ? TRUE : FALSE; gimage->quick_mask_state = quick_mask_state ? TRUE : FALSE;
selection = gimp_image_get_mask (gimage); selection = gimp_image_get_mask (gimage);
mask = gimp_image_get_qmask (gimage); mask = gimp_image_get_quick_mask (gimage);
if (qmask_state) if (quick_mask_state)
{ {
if (! mask) if (! mask)
{ {
gimp_image_undo_group_start (gimage, GIMP_UNDO_GROUP_IMAGE_QMASK, gimp_image_undo_group_start (gimage, GIMP_UNDO_GROUP_IMAGE_QUICK_MASK,
_("Enable Quick Mask")); _("Enable Quick Mask"));
if (gimp_channel_is_empty (selection)) if (gimp_channel_is_empty (selection))
@ -78,8 +78,8 @@ gimp_image_set_qmask_state (GimpImage *gimage,
mask = gimp_channel_new (gimage, mask = gimp_channel_new (gimage,
gimage->width, gimage->width,
gimage->height, gimage->height,
GIMP_IMAGE_QMASK_NAME, GIMP_IMAGE_QUICK_MASK_NAME,
&gimage->qmask_color); &gimage->quick_mask_color);
/* Clear the mask */ /* Clear the mask */
gimp_channel_clear (mask, NULL, FALSE); gimp_channel_clear (mask, NULL, FALSE);
@ -95,11 +95,11 @@ gimp_image_set_qmask_state (GimpImage *gimage,
/* Clear the selection */ /* Clear the selection */
gimp_channel_clear (selection, NULL, TRUE); gimp_channel_clear (selection, NULL, TRUE);
gimp_channel_set_color (mask, &gimage->qmask_color, FALSE); gimp_channel_set_color (mask, &gimage->quick_mask_color, FALSE);
gimp_item_rename (GIMP_ITEM (mask), GIMP_IMAGE_QMASK_NAME); gimp_item_rename (GIMP_ITEM (mask), GIMP_IMAGE_QUICK_MASK_NAME);
} }
if (gimage->qmask_inverted) if (gimage->quick_mask_inverted)
gimp_channel_invert (mask, FALSE); gimp_channel_invert (mask, FALSE);
gimp_image_add_channel (gimage, mask, 0); gimp_image_add_channel (gimage, mask, 0);
@ -113,10 +113,10 @@ gimp_image_set_qmask_state (GimpImage *gimage,
{ {
GimpLayer *floating_sel = gimp_image_floating_sel (gimage); GimpLayer *floating_sel = gimp_image_floating_sel (gimage);
gimp_image_undo_group_start (gimage, GIMP_UNDO_GROUP_IMAGE_QMASK, gimp_image_undo_group_start (gimage, GIMP_UNDO_GROUP_IMAGE_QUICK_MASK,
_("Disable Quick Mask")); _("Disable Quick Mask"));
if (gimage->qmask_inverted) if (gimage->quick_mask_inverted)
gimp_channel_invert (mask, TRUE); gimp_channel_invert (mask, TRUE);
if (floating_sel && floating_sel->fs.drawable == GIMP_DRAWABLE (mask)) if (floating_sel && floating_sel->fs.drawable == GIMP_DRAWABLE (mask))
@ -129,63 +129,63 @@ gimp_image_set_qmask_state (GimpImage *gimage,
} }
} }
gimp_image_qmask_changed (gimage); gimp_image_quick_mask_changed (gimage);
} }
gboolean gboolean
gimp_image_get_qmask_state (const GimpImage *gimage) gimp_image_get_quick_mask_state (const GimpImage *gimage)
{ {
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE); g_return_val_if_fail (GIMP_IS_IMAGE (gimage), FALSE);
return gimage->qmask_state; return gimage->quick_mask_state;
} }
void void
gimp_image_set_qmask_color (GimpImage *gimage, gimp_image_set_quick_mask_color (GimpImage *gimage,
const GimpRGB *color) const GimpRGB *color)
{ {
GimpChannel *qmask; GimpChannel *quick_mask;
g_return_if_fail (GIMP_IS_IMAGE (gimage)); g_return_if_fail (GIMP_IS_IMAGE (gimage));
g_return_if_fail (color != NULL); g_return_if_fail (color != NULL);
gimage->qmask_color = *color; gimage->quick_mask_color = *color;
qmask = gimp_image_get_qmask (gimage); quick_mask = gimp_image_get_quick_mask (gimage);
if (qmask) if (quick_mask)
gimp_channel_set_color (qmask, color, TRUE); gimp_channel_set_color (quick_mask, color, TRUE);
} }
void void
gimp_image_get_qmask_color (const GimpImage *gimage, gimp_image_get_quick_mask_color (const GimpImage *gimage,
GimpRGB *color) GimpRGB *color)
{ {
g_return_if_fail (GIMP_IS_IMAGE (gimage)); g_return_if_fail (GIMP_IS_IMAGE (gimage));
g_return_if_fail (color != NULL); g_return_if_fail (color != NULL);
*color = gimage->qmask_color; *color = gimage->quick_mask_color;
} }
GimpChannel * GimpChannel *
gimp_image_get_qmask (const GimpImage *gimage) gimp_image_get_quick_mask (const GimpImage *gimage)
{ {
g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL); g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
return gimp_image_get_channel_by_name (gimage, GIMP_IMAGE_QMASK_NAME); return gimp_image_get_channel_by_name (gimage, GIMP_IMAGE_QUICK_MASK_NAME);
} }
void void
gimp_image_qmask_invert (GimpImage *gimage) gimp_image_quick_mask_invert (GimpImage *gimage)
{ {
g_return_if_fail (GIMP_IS_IMAGE (gimage)); g_return_if_fail (GIMP_IS_IMAGE (gimage));
if (gimage->qmask_state) if (gimage->quick_mask_state)
{ {
GimpChannel *qmask = gimp_image_get_qmask (gimage); GimpChannel *quick_mask = gimp_image_get_quick_mask (gimage);
if (qmask) if (quick_mask)
gimp_channel_invert (qmask, TRUE); gimp_channel_invert (quick_mask, TRUE);
} }
gimage->qmask_inverted = ! gimage->qmask_inverted; gimage->quick_mask_inverted = ! gimage->quick_mask_inverted;
} }

26
app/core/gimpimage-quick-mask.h
View File

@ -16,28 +16,28 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/ */
#ifndef __GIMP_IMAGE_QMASK_H__ #ifndef __GIMP_IMAGE_QUICK_MASK_H__
#define __GIMP_IMAGE_QMASK_H__ #define __GIMP_IMAGE_QUICK_MASK_H__
/* don't change this string, it's used to identify the Quick Mask /* don't change this string, it's used to identify the Quick Mask
* when opening files. * when opening files.
*/ */
#define GIMP_IMAGE_QMASK_NAME "Qmask" #define GIMP_IMAGE_QUICK_MASK_NAME "Qmask"
void gimp_image_set_qmask_state (GimpImage *gimage, void gimp_image_set_quick_mask_state (GimpImage *gimage,
gboolean qmask_state); gboolean quick_mask_state);
gboolean gimp_image_get_qmask_state (const GimpImage *gimage); gboolean gimp_image_get_quick_mask_state (const GimpImage *gimage);
void gimp_image_set_qmask_color (GimpImage *gimage, void gimp_image_set_quick_mask_color (GimpImage *gimage,
const GimpRGB *color); const GimpRGB *color);
void gimp_image_get_qmask_color (const GimpImage *gimage, void gimp_image_get_quick_mask_color (const GimpImage *gimage,
GimpRGB *color); GimpRGB *color);
GimpChannel * gimp_image_get_qmask (const GimpImage *gimage); GimpChannel * gimp_image_get_quick_mask (const GimpImage *gimage);
void gimp_image_qmask_invert (GimpImage *gimage); void gimp_image_quick_mask_invert (GimpImage *gimage);
#endif /* __GIMP_IMAGE_QMASK_H__ */ #endif /* __GIMP_IMAGE_QUICK_MASK_H__ */

6
app/core/gimpimage-undo.c
View File

@ -339,8 +339,8 @@ gimp_image_undo_pop_stack (GimpImage *gimage,
if (accum.unit_changed) if (accum.unit_changed)
gimp_image_unit_changed (gimage); gimp_image_unit_changed (gimage);
if (accum.qmask_changed) if (accum.quick_mask_changed)
gimp_image_qmask_changed (gimage); gimp_image_quick_mask_changed (gimage);
if (accum.alpha_changed) if (accum.alpha_changed)
gimp_image_alpha_changed (gimage); gimp_image_alpha_changed (gimage);
@ -453,7 +453,7 @@ gimp_image_undo_dirty_from_type (GimpUndoType undo_type)
case GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE: case GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE:
return GIMP_DIRTY_IMAGE_STRUCTURE | GIMP_DIRTY_VECTORS; return GIMP_DIRTY_IMAGE_STRUCTURE | GIMP_DIRTY_VECTORS;
case GIMP_UNDO_GROUP_IMAGE_QMASK: /* FIXME */ case GIMP_UNDO_GROUP_IMAGE_QUICK_MASK: /* FIXME */
return GIMP_DIRTY_IMAGE_STRUCTURE | GIMP_DIRTY_SELECTION; return GIMP_DIRTY_IMAGE_STRUCTURE | GIMP_DIRTY_SELECTION;
case GIMP_UNDO_GROUP_IMAGE_GRID: case GIMP_UNDO_GROUP_IMAGE_GRID:

42
app/core/gimpimage.c
View File

@ -46,7 +46,7 @@
#include "gimpimage-guides.h" #include "gimpimage-guides.h"
#include "gimpimage-sample-points.h" #include "gimpimage-sample-points.h"
#include "gimpimage-preview.h" #include "gimpimage-preview.h"
#include "gimpimage-qmask.h" #include "gimpimage-quick-mask.h"
#include "gimpimage-undo.h" #include "gimpimage-undo.h"
#include "gimpimage-undo-push.h" #include "gimpimage-undo-push.h"
#include "gimplayer.h" #include "gimplayer.h"
@ -88,7 +88,7 @@ enum
MASK_CHANGED, MASK_CHANGED,
RESOLUTION_CHANGED, RESOLUTION_CHANGED,
UNIT_CHANGED, UNIT_CHANGED,
QMASK_CHANGED, QUICK_MASK_CHANGED,
SELECTION_CONTROL, SELECTION_CONTROL,
CLEAN, CLEAN,
DIRTY, DIRTY,
@ -344,11 +344,11 @@ gimp_image_class_init (GimpImageClass *klass)
gimp_marshal_VOID__VOID, gimp_marshal_VOID__VOID,
G_TYPE_NONE, 0); G_TYPE_NONE, 0);
gimp_image_signals[QMASK_CHANGED] = gimp_image_signals[QUICK_MASK_CHANGED] =
g_signal_new ("qmask-changed", g_signal_new ("quick-mask-changed",
G_TYPE_FROM_CLASS (klass), G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpImageClass, qmask_changed), G_STRUCT_OFFSET (GimpImageClass, quick_mask_changed),
NULL, NULL, NULL, NULL,
gimp_marshal_VOID__VOID, gimp_marshal_VOID__VOID,
G_TYPE_NONE, 0); G_TYPE_NONE, 0);
@ -639,9 +639,9 @@ gimp_image_init (GimpImage *gimage)
gimage->active[i] = TRUE; gimage->active[i] = TRUE;
} }
gimage->qmask_state = FALSE; gimage->quick_mask_state = FALSE;
gimage->qmask_inverted = FALSE; gimage->quick_mask_inverted = FALSE;
gimp_rgba_set (&gimage->qmask_color, 1.0, 0.0, 0.0, 0.5); gimp_rgba_set (&gimage->quick_mask_color, 1.0, 0.0, 0.0, 0.5);
gimage->undo_stack = gimp_undo_stack_new (gimage); gimage->undo_stack = gimp_undo_stack_new (gimage);
gimage->redo_stack = gimp_undo_stack_new (gimage); gimage->redo_stack = gimp_undo_stack_new (gimage);
@ -1204,10 +1204,10 @@ gimp_image_channel_add (GimpContainer *container,
if (gimp_item_get_visible (item)) if (gimp_item_get_visible (item))
gimp_image_drawable_visibility (item, gimage); gimp_image_drawable_visibility (item, gimage);
if (! strcmp (GIMP_IMAGE_QMASK_NAME, if (! strcmp (GIMP_IMAGE_QUICK_MASK_NAME,
gimp_object_get_name (GIMP_OBJECT (channel)))) gimp_object_get_name (GIMP_OBJECT (channel))))
{ {
gimp_image_set_qmask_state (gimage, TRUE); gimp_image_set_quick_mask_state (gimage, TRUE);
} }
} }
@ -1221,10 +1221,10 @@ gimp_image_channel_remove (GimpContainer *container,
if (gimp_item_get_visible (item)) if (gimp_item_get_visible (item))
gimp_image_drawable_visibility (item, gimage); gimp_image_drawable_visibility (item, gimage);
if (! strcmp (GIMP_IMAGE_QMASK_NAME, if (! strcmp (GIMP_IMAGE_QUICK_MASK_NAME,
gimp_object_get_name (GIMP_OBJECT (channel)))) gimp_object_get_name (GIMP_OBJECT (channel))))
{ {
gimp_image_set_qmask_state (gimage, FALSE); gimp_image_set_quick_mask_state (gimage, FALSE);
} }
} }
@ -1232,15 +1232,15 @@ static void
gimp_image_channel_name_changed (GimpChannel *channel, gimp_image_channel_name_changed (GimpChannel *channel,
GimpImage *gimage) GimpImage *gimage)
{ {
if (! strcmp (GIMP_IMAGE_QMASK_NAME, if (! strcmp (GIMP_IMAGE_QUICK_MASK_NAME,
gimp_object_get_name (GIMP_OBJECT (channel)))) gimp_object_get_name (GIMP_OBJECT (channel))))
{ {
gimp_image_set_qmask_state (gimage, TRUE); gimp_image_set_quick_mask_state (gimage, TRUE);
} }
else if (gimp_image_get_qmask_state (gimage) && else if (gimp_image_get_quick_mask_state (gimage) &&
! gimp_image_get_qmask (gimage)) ! gimp_image_get_quick_mask (gimage))
{ {
gimp_image_set_qmask_state (gimage, FALSE); gimp_image_set_quick_mask_state (gimage, FALSE);
} }
} }
@ -1248,10 +1248,10 @@ static void
gimp_image_channel_color_changed (GimpChannel *channel, gimp_image_channel_color_changed (GimpChannel *channel,
GimpImage *gimage) GimpImage *gimage)
{ {
if (! strcmp (GIMP_IMAGE_QMASK_NAME, if (! strcmp (GIMP_IMAGE_QUICK_MASK_NAME,
gimp_object_get_name (GIMP_OBJECT (channel)))) gimp_object_get_name (GIMP_OBJECT (channel))))
{ {
gimage->qmask_color = channel->color; gimage->quick_mask_color = channel->color;
} }
} }
@ -1752,11 +1752,11 @@ gimp_image_selection_control (GimpImage *gimage,
} }
void void
gimp_image_qmask_changed (GimpImage *gimage) gimp_image_quick_mask_changed (GimpImage *gimage)
{ {
g_return_if_fail (GIMP_IS_IMAGE (gimage)); g_return_if_fail (GIMP_IS_IMAGE (gimage));
g_signal_emit (gimage, gimp_image_signals[QMASK_CHANGED], 0); g_signal_emit (gimage, gimp_image_signals[QUICK_MASK_CHANGED], 0);
} }

10
app/core/gimpimage.h
View File

@ -157,9 +157,9 @@ struct _GimpImage
gboolean visible[MAX_CHANNELS]; /* visible channels */ gboolean visible[MAX_CHANNELS]; /* visible channels */
gboolean active[MAX_CHANNELS]; /* active channels */ gboolean active[MAX_CHANNELS]; /* active channels */
gboolean qmask_state; /* TRUE if qmask is on */ gboolean quick_mask_state; /* TRUE if quick mask is on */
gboolean qmask_inverted; /* TRUE if qmask is inverted */ gboolean quick_mask_inverted; /* TRUE if quick mask is inverted */
GimpRGB qmask_color; /* rgba triplet of the color */ GimpRGB quick_mask_color; /* rgba triplet of the color */
/* Undo apparatus */ /* Undo apparatus */
GimpUndoStack *undo_stack; /* stack for undo operations */ GimpUndoStack *undo_stack; /* stack for undo operations */
@ -193,7 +193,7 @@ struct _GimpImageClass
void (* mask_changed) (GimpImage *gimage); void (* mask_changed) (GimpImage *gimage);
void (* resolution_changed) (GimpImage *gimage); void (* resolution_changed) (GimpImage *gimage);
void (* unit_changed) (GimpImage *gimage); void (* unit_changed) (GimpImage *gimage);
void (* qmask_changed) (GimpImage *gimage); void (* quick_mask_changed) (GimpImage *gimage);
void (* selection_control) (GimpImage *gimage, void (* selection_control) (GimpImage *gimage,
GimpSelectionControl control); GimpSelectionControl control);
@ -311,7 +311,7 @@ void gimp_image_colormap_changed (GimpImage *gimage,
gint col); gint col);
void gimp_image_selection_control (GimpImage *gimage, void gimp_image_selection_control (GimpImage *gimage,
GimpSelectionControl control); GimpSelectionControl control);
void gimp_image_qmask_changed (GimpImage *gimage); void gimp_image_quick_mask_changed (GimpImage *gimage);
/* undo */ /* undo */

12
app/core/gimpundo.c
View File

@ -484,15 +484,15 @@ gimp_undo_create_preview_idle (gpointer data)
static void static void
gimp_undo_create_preview_private (GimpUndo *undo) gimp_undo_create_preview_private (GimpUndo *undo)
{ {
GimpImage *image = undo->gimage; GimpImage *image = undo->gimage;
GimpViewable *preview_viewable; GimpViewable *preview_viewable;
GimpViewSize preview_size; GimpViewSize preview_size;
gint width; gint width;
gint height; gint height;
switch (undo->undo_type) switch (undo->undo_type)
{ {
case GIMP_UNDO_GROUP_IMAGE_QMASK: case GIMP_UNDO_GROUP_IMAGE_QUICK_MASK:
case GIMP_UNDO_GROUP_MASK: case GIMP_UNDO_GROUP_MASK:
case GIMP_UNDO_MASK: case GIMP_UNDO_MASK:
preview_viewable = GIMP_VIEWABLE (gimp_image_get_mask (image)); preview_viewable = GIMP_VIEWABLE (gimp_image_get_mask (image));

2
app/core/gimpundo.h
View File

@ -29,7 +29,7 @@ struct _GimpUndoAccumulator
gboolean size_changed; gboolean size_changed;
gboolean resolution_changed; gboolean resolution_changed;
gboolean unit_changed; gboolean unit_changed;
gboolean qmask_changed; gboolean quick_mask_changed;
gboolean alpha_changed; gboolean alpha_changed;
}; };

4
app/display/gimpdisplayshell-appearance.c
View File

@ -190,7 +190,7 @@ gimp_display_shell_set_show_scrollbars (GimpDisplayShell *shell,
gtk_widget_show (shell->nav_ebox); gtk_widget_show (shell->nav_ebox);
gtk_widget_show (shell->hsb); gtk_widget_show (shell->hsb);
gtk_widget_show (shell->vsb); gtk_widget_show (shell->vsb);
gtk_widget_show (shell->qmask_button); gtk_widget_show (shell->quick_mask_button);
gtk_widget_show (shell->zoom_button); gtk_widget_show (shell->zoom_button);
gtk_box_set_spacing (hbox, 1); gtk_box_set_spacing (hbox, 1);
@ -201,7 +201,7 @@ gimp_display_shell_set_show_scrollbars (GimpDisplayShell *shell,
gtk_widget_hide (shell->nav_ebox); gtk_widget_hide (shell->nav_ebox);
gtk_widget_hide (shell->hsb); gtk_widget_hide (shell->hsb);
gtk_widget_hide (shell->vsb); gtk_widget_hide (shell->vsb);
gtk_widget_hide (shell->qmask_button); gtk_widget_hide (shell->quick_mask_button);
gtk_widget_hide (shell->zoom_button); gtk_widget_hide (shell->zoom_button);
gtk_box_set_spacing (hbox, 0); gtk_box_set_spacing (hbox, 0);

20
app/display/gimpdisplayshell-callbacks.c
View File

@ -37,7 +37,7 @@
#include "core/gimpimage.h" #include "core/gimpimage.h"
#include "core/gimpimage-guides.h" #include "core/gimpimage-guides.h"
#include "core/gimpimage-sample-points.h" #include "core/gimpimage-sample-points.h"
#include "core/gimpimage-qmask.h" #include "core/gimpimage-quick-mask.h"
#include "core/gimplayer.h" #include "core/gimplayer.h"
#include "core/gimptoolinfo.h" #include "core/gimptoolinfo.h"
@ -1453,13 +1453,13 @@ gimp_display_shell_origin_button_press (GtkWidget *widget,
} }
gboolean gboolean
gimp_display_shell_qmask_button_press (GtkWidget *widget, gimp_display_shell_quick_mask_button_press (GtkWidget *widget,
GdkEventButton *bevent, GdkEventButton *bevent,
GimpDisplayShell *shell) GimpDisplayShell *shell)
{ {
if ((bevent->type == GDK_BUTTON_PRESS) && (bevent->button == 3)) if ((bevent->type == GDK_BUTTON_PRESS) && (bevent->button == 3))
{ {
gimp_ui_manager_ui_popup (shell->menubar_manager, "/qmask-popup", gimp_ui_manager_ui_popup (shell->menubar_manager, "/quick-mask-popup",
GTK_WIDGET (shell), GTK_WIDGET (shell),
NULL, NULL, NULL, NULL); NULL, NULL, NULL, NULL);
@ -1470,14 +1470,14 @@ gimp_display_shell_qmask_button_press (GtkWidget *widget,
} }
void void
gimp_display_shell_qmask_toggled (GtkWidget *widget, gimp_display_shell_quick_mask_toggled (GtkWidget *widget,
GimpDisplayShell *shell) GimpDisplayShell *shell)
{ {
if (GTK_TOGGLE_BUTTON (widget)->active != if (GTK_TOGGLE_BUTTON (widget)->active !=
gimp_image_get_qmask_state (shell->gdisp->gimage)) gimp_image_get_quick_mask_state (shell->gdisp->gimage))
{ {
gimp_image_set_qmask_state (shell->gdisp->gimage, gimp_image_set_quick_mask_state (shell->gdisp->gimage,
GTK_TOGGLE_BUTTON (widget)->active); GTK_TOGGLE_BUTTON (widget)->active);
gimp_image_flush (shell->gdisp->gimage); gimp_image_flush (shell->gdisp->gimage);
} }

62
app/display/gimpdisplayshell-callbacks.h
View File

@ -34,42 +34,42 @@
GDK_PROXIMITY_OUT_MASK) GDK_PROXIMITY_OUT_MASK)
gboolean gimp_display_shell_events (GtkWidget *widget, gboolean gimp_display_shell_events (GtkWidget *widget,
GdkEvent *event, GdkEvent *event,
GimpDisplayShell *shell); GimpDisplayShell *shell);
void gimp_display_shell_canvas_realize (GtkWidget *widget, void gimp_display_shell_canvas_realize (GtkWidget *widget,
GimpDisplayShell *shell); GimpDisplayShell *shell);
void gimp_display_shell_canvas_size_allocate (GtkWidget *widget, void gimp_display_shell_canvas_size_allocate (GtkWidget *widget,
GtkAllocation *alloc, GtkAllocation *alloc,
GimpDisplayShell *shell); GimpDisplayShell *shell);
gboolean gimp_display_shell_canvas_expose (GtkWidget *widget, gboolean gimp_display_shell_canvas_expose (GtkWidget *widget,
GdkEventExpose *eevent, GdkEventExpose *eevent,
GimpDisplayShell *shell); GimpDisplayShell *shell);
gboolean gimp_display_shell_canvas_tool_events (GtkWidget *widget, gboolean gimp_display_shell_canvas_tool_events (GtkWidget *widget,
GdkEvent *event, GdkEvent *event,
GimpDisplayShell *shell); GimpDisplayShell *shell);
gboolean gimp_display_shell_hruler_button_press (GtkWidget *widget, gboolean gimp_display_shell_hruler_button_press (GtkWidget *widget,
GdkEventButton *bevent, GdkEventButton *bevent,
GimpDisplayShell *shell); GimpDisplayShell *shell);
gboolean gimp_display_shell_vruler_button_press (GtkWidget *widget, gboolean gimp_display_shell_vruler_button_press (GtkWidget *widget,
GdkEventButton *bevent, GdkEventButton *bevent,
GimpDisplayShell *shell); GimpDisplayShell *shell);
gboolean gimp_display_shell_origin_button_press (GtkWidget *widget, gboolean gimp_display_shell_origin_button_press (GtkWidget *widget,
GdkEventButton *bevent, GdkEventButton *bevent,
GimpDisplayShell *shell); GimpDisplayShell *shell);
gboolean gimp_display_shell_qmask_button_press (GtkWidget *widget, gboolean gimp_display_shell_quick_mask_button_press (GtkWidget *widget,
GdkEventButton *bevent, GdkEventButton *bevent,
GimpDisplayShell *shell); GimpDisplayShell *shell);
void gimp_display_shell_qmask_toggled (GtkWidget *widget, void gimp_display_shell_quick_mask_toggled (GtkWidget *widget,
GimpDisplayShell *shell); GimpDisplayShell *shell);
gboolean gimp_display_shell_nav_button_press (GtkWidget *widget, gboolean gimp_display_shell_nav_button_press (GtkWidget *widget,
GdkEventButton *bevent, GdkEventButton *bevent,
GimpDisplayShell *shell); GimpDisplayShell *shell);
#endif /* __GIMP_DISPLAY_SHELL_CALLBACKS_H__ */ #endif /* __GIMP_DISPLAY_SHELL_CALLBACKS_H__ */

36
app/display/gimpdisplayshell-handlers.c
View File

@ -68,7 +68,7 @@ static void gimp_display_shell_size_changed_handler (GimpImage *g
GimpDisplayShell *shell); GimpDisplayShell *shell);
static void gimp_display_shell_resolution_changed_handler (GimpImage *gimage, static void gimp_display_shell_resolution_changed_handler (GimpImage *gimage,
GimpDisplayShell *shell); GimpDisplayShell *shell);
static void gimp_display_shell_qmask_changed_handler (GimpImage *gimage, static void gimp_display_shell_quick_mask_changed_handler (GimpImage *gimage,
GimpDisplayShell *shell); GimpDisplayShell *shell);
static void gimp_display_shell_update_guide_handler (GimpImage *gimage, static void gimp_display_shell_update_guide_handler (GimpImage *gimage,
GimpGuide *guide, GimpGuide *guide,
@ -154,8 +154,8 @@ gimp_display_shell_connect (GimpDisplayShell *shell)
g_signal_connect (gimage, "resolution-changed", g_signal_connect (gimage, "resolution-changed",
G_CALLBACK (gimp_display_shell_resolution_changed_handler), G_CALLBACK (gimp_display_shell_resolution_changed_handler),
shell); shell);
g_signal_connect (gimage, "qmask-changed", g_signal_connect (gimage, "quick-mask-changed",
G_CALLBACK (gimp_display_shell_qmask_changed_handler), G_CALLBACK (gimp_display_shell_quick_mask_changed_handler),
shell); shell);
g_signal_connect (gimage, "update-guide", g_signal_connect (gimage, "update-guide",
G_CALLBACK (gimp_display_shell_update_guide_handler), G_CALLBACK (gimp_display_shell_update_guide_handler),
@ -244,7 +244,7 @@ gimp_display_shell_connect (GimpDisplayShell *shell)
shell); shell);
gimp_display_shell_invalidate_preview_handler (gimage, shell); gimp_display_shell_invalidate_preview_handler (gimage, shell);
gimp_display_shell_qmask_changed_handler (gimage, shell); gimp_display_shell_quick_mask_changed_handler (gimage, shell);
} }
void void
@ -325,7 +325,7 @@ gimp_display_shell_disconnect (GimpDisplayShell *shell)
gimp_display_shell_update_sample_point_handler, gimp_display_shell_update_sample_point_handler,
shell); shell);
g_signal_handlers_disconnect_by_func (gimage, g_signal_handlers_disconnect_by_func (gimage,
gimp_display_shell_qmask_changed_handler, gimp_display_shell_quick_mask_changed_handler,
shell); shell);
g_signal_handlers_disconnect_by_func (gimage, g_signal_handlers_disconnect_by_func (gimage,
gimp_display_shell_resolution_changed_handler, gimp_display_shell_resolution_changed_handler,
@ -427,27 +427,29 @@ gimp_display_shell_resolution_changed_handler (GimpImage *gimage,
} }
static void static void
gimp_display_shell_qmask_changed_handler (GimpImage *gimage, gimp_display_shell_quick_mask_changed_handler (GimpImage *gimage,
GimpDisplayShell *shell) GimpDisplayShell *shell)
{ {
GtkImage *image; GtkImage *image;
image = GTK_IMAGE (GTK_BIN (shell->qmask_button)->child); image = GTK_IMAGE (GTK_BIN (shell->quick_mask_button)->child);
g_signal_handlers_block_by_func (shell->qmask_button, g_signal_handlers_block_by_func (shell->quick_mask_button,
gimp_display_shell_qmask_toggled, gimp_display_shell_quick_mask_toggled,
shell); shell);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (shell->qmask_button), gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (shell->quick_mask_button),
shell->gdisp->gimage->qmask_state); shell->gdisp->gimage->quick_mask_state);
if (shell->gdisp->gimage->qmask_state) if (shell->gdisp->gimage->quick_mask_state)
gtk_image_set_from_stock (image, GIMP_STOCK_QMASK_ON, GTK_ICON_SIZE_MENU); gtk_image_set_from_stock (image, GIMP_STOCK_QUICK_MASK_ON,
GTK_ICON_SIZE_MENU);
else else
gtk_image_set_from_stock (image, GIMP_STOCK_QMASK_OFF, GTK_ICON_SIZE_MENU); gtk_image_set_from_stock (image, GIMP_STOCK_QUICK_MASK_OFF,
GTK_ICON_SIZE_MENU);
g_signal_handlers_unblock_by_func (shell->qmask_button, g_signal_handlers_unblock_by_func (shell->quick_mask_button,
gimp_display_shell_qmask_toggled, gimp_display_shell_quick_mask_toggled,
shell); shell);
} }

38
app/display/gimpdisplayshell.c
View File

@ -265,7 +265,7 @@ gimp_display_shell_init (GimpDisplayShell *shell)
shell->vrule = NULL; shell->vrule = NULL;
shell->origin_button = NULL; shell->origin_button = NULL;
shell->qmask_button = NULL; shell->quick_mask_button = NULL;
shell->zoom_button = NULL; shell->zoom_button = NULL;
shell->nav_ebox = NULL; shell->nav_ebox = NULL;
@ -718,7 +718,7 @@ gimp_display_shell_new (GimpDisplay *gdisp,
* | | * | |
* | +-- lower_hbox * | +-- lower_hbox
* | | * | |
* | +-- qmask * | +-- quick_mask
* | +-- hscrollbar * | +-- hscrollbar
* | +-- navbutton * | +-- navbutton
* | * |
@ -786,7 +786,7 @@ gimp_display_shell_new (GimpDisplay *gdisp,
gtk_box_pack_start (GTK_BOX (upper_hbox), right_vbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (upper_hbox), right_vbox, FALSE, FALSE, 0);
gtk_widget_show (right_vbox); gtk_widget_show (right_vbox);
/* the hbox containing qmask button, vertical scrollbar and nav button */ /* the hbox containing quickmask button, vertical scrollbar and nav button */
lower_hbox = gtk_hbox_new (FALSE, 1); lower_hbox = gtk_hbox_new (FALSE, 1);
gtk_box_pack_start (GTK_BOX (disp_vbox), lower_hbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (disp_vbox), lower_hbox, FALSE, FALSE, 0);
gtk_widget_show (lower_hbox); gtk_widget_show (lower_hbox);
@ -928,25 +928,27 @@ gimp_display_shell_new (GimpDisplay *gdisp,
/* create the contents of the lower_hbox *********************************/ /* create the contents of the lower_hbox *********************************/
/* the qmask button */ /* the quick mask button */
shell->qmask_button = gtk_check_button_new (); shell->quick_mask_button = gtk_check_button_new ();
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (shell->qmask_button), FALSE); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (shell->quick_mask_button),
gtk_widget_set_size_request (GTK_WIDGET (shell->qmask_button), 16, 16); FALSE);
GTK_WIDGET_UNSET_FLAGS (shell->qmask_button, GTK_CAN_FOCUS); gtk_widget_set_size_request (GTK_WIDGET (shell->quick_mask_button), 16, 16);
GTK_WIDGET_UNSET_FLAGS (shell->quick_mask_button, GTK_CAN_FOCUS);
image = gtk_image_new_from_stock (GIMP_STOCK_QMASK_OFF, GTK_ICON_SIZE_MENU); image = gtk_image_new_from_stock (GIMP_STOCK_QUICK_MASK_OFF,
gtk_container_add (GTK_CONTAINER (shell->qmask_button), image); GTK_ICON_SIZE_MENU);
gtk_container_add (GTK_CONTAINER (shell->quick_mask_button), image);
gtk_widget_show (image); gtk_widget_show (image);
gimp_help_set_help_data (shell->qmask_button, gimp_help_set_help_data (shell->quick_mask_button,
_("Toggle Quick Mask"), _("Toggle Quick Mask"),
GIMP_HELP_IMAGE_WINDOW_QMASK_BUTTON); GIMP_HELP_IMAGE_WINDOW_QUICK_MASK_BUTTON);
g_signal_connect (shell->qmask_button, "toggled", g_signal_connect (shell->quick_mask_button, "toggled",
G_CALLBACK (gimp_display_shell_qmask_toggled), G_CALLBACK (gimp_display_shell_quick_mask_toggled),
shell); shell);
g_signal_connect (shell->qmask_button, "button-press-event", g_signal_connect (shell->quick_mask_button, "button-press-event",
G_CALLBACK (gimp_display_shell_qmask_button_press), G_CALLBACK (gimp_display_shell_quick_mask_button_press),
shell); shell);
/* the navigation window button */ /* the navigation window button */
@ -988,7 +990,7 @@ gimp_display_shell_new (GimpDisplay *gdisp,
gtk_box_pack_start (GTK_BOX (right_vbox), shell->vsb, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (right_vbox), shell->vsb, TRUE, TRUE, 0);
/* fill the lower_hbox */ /* fill the lower_hbox */
gtk_box_pack_start (GTK_BOX (lower_hbox), shell->qmask_button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (lower_hbox), shell->quick_mask_button, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (lower_hbox), shell->hsb, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (lower_hbox), shell->hsb, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (lower_hbox), shell->nav_ebox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (lower_hbox), shell->nav_ebox, FALSE, FALSE, 0);
@ -1010,7 +1012,7 @@ gimp_display_shell_new (GimpDisplay *gdisp,
gtk_widget_show (shell->vsb); gtk_widget_show (shell->vsb);
gtk_widget_show (shell->hsb); gtk_widget_show (shell->hsb);
gtk_widget_show (shell->zoom_button); gtk_widget_show (shell->zoom_button);
gtk_widget_show (shell->qmask_button); gtk_widget_show (shell->quick_mask_button);
gtk_widget_show (shell->nav_ebox); gtk_widget_show (shell->nav_ebox);
} }

2
app/display/gimpdisplayshell.h
View File

@ -107,7 +107,7 @@ struct _GimpDisplayShell
GtkWidget *vrule; GtkWidget *vrule;
GtkWidget *origin_button; /* NW: origin button */ GtkWidget *origin_button; /* NW: origin button */
GtkWidget *qmask_button; /* SW: qmask button */ GtkWidget *quick_mask_button; /* SW: quick mask button */
GtkWidget *zoom_button; /* NE: zoom toggle button */ GtkWidget *zoom_button; /* NE: zoom toggle button */
GtkWidget *nav_ebox; /* SE: navigation event box */ GtkWidget *nav_ebox; /* SE: navigation event box */

10
app/menus/menus.c
View File

@ -100,14 +100,14 @@ menus_init (Gimp *gimp,
"tools", "tools",
"dialogs", "dialogs",
"plug-in", "plug-in",
"qmask", "quick-mask",
NULL, NULL,
"/image-menubar", "/image-menubar",
"image-menu.xml", image_menu_setup, "image-menu.xml", image_menu_setup,
"/dummy-menubar", "/dummy-menubar",
"image-menu.xml", image_menu_setup, "image-menu.xml", image_menu_setup,
"/qmask-popup", "/quick-mask-popup",
"qmask-menu.xml", NULL, "quick-mask-menu.xml", NULL,
NULL); NULL);
gimp_menu_factory_manager_register (global_menu_factory, "<Toolbox>", gimp_menu_factory_manager_register (global_menu_factory, "<Toolbox>",
@ -125,7 +125,7 @@ menus_init (Gimp *gimp,
"tools", "tools",
"dialogs", "dialogs",
"plug-in", "plug-in",
"qmask", "quick-mask",
NULL, NULL,
"/toolbox-menubar", "/toolbox-menubar",
"toolbox-menu.xml", toolbox_menu_setup, "toolbox-menu.xml", toolbox_menu_setup,
@ -144,7 +144,7 @@ menus_init (Gimp *gimp,
"tools", "tools",
"dialogs", "dialogs",
"plug-in", "plug-in",
"qmask", "quick-mask",
"dock", "dock",
NULL, NULL,
NULL); NULL);

10
app/widgets/gimphelp-ids.h
View File

@ -98,7 +98,7 @@
#define GIMP_HELP_IMAGE_WINDOW_ORIGIN_BUTTON "gimp-image-window-origin-button" #define GIMP_HELP_IMAGE_WINDOW_ORIGIN_BUTTON "gimp-image-window-origin-button"
#define GIMP_HELP_IMAGE_WINDOW_PADDING_BUTTON "gimp-image-window-padding-button" #define GIMP_HELP_IMAGE_WINDOW_PADDING_BUTTON "gimp-image-window-padding-button"
#define GIMP_HELP_IMAGE_WINDOW_ZOOM_FOLLOW_BUTTON "gimp-image-window-zoom-follow-button" #define GIMP_HELP_IMAGE_WINDOW_ZOOM_FOLLOW_BUTTON "gimp-image-window-zoom-follow-button"
#define GIMP_HELP_IMAGE_WINDOW_QMASK_BUTTON "gimp-image-window-qmask-button" #define GIMP_HELP_IMAGE_WINDOW_QUICK_MASK_BUTTON "gimp-image-window-quick-mask-button"
#define GIMP_HELP_IMAGE_WINDOW_NAV_BUTTON "gimp-image-window-nav-button" #define GIMP_HELP_IMAGE_WINDOW_NAV_BUTTON "gimp-image-window-nav-button"
#define GIMP_HELP_IMAGE_WINDOW_RULER "gimp-image-window-ruler" #define GIMP_HELP_IMAGE_WINDOW_RULER "gimp-image-window-ruler"
#define GIMP_HELP_IMAGE_WINDOW_STATUS_BAR "gimp-image-window-status-bar" #define GIMP_HELP_IMAGE_WINDOW_STATUS_BAR "gimp-image-window-status-bar"
@ -195,10 +195,10 @@
#define GIMP_HELP_CHANNEL_SELECTION_INTERSECT "gimp-channel-selection-intersect" #define GIMP_HELP_CHANNEL_SELECTION_INTERSECT "gimp-channel-selection-intersect"
#define GIMP_HELP_CHANNEL_EDIT "gimp-channel-edit" #define GIMP_HELP_CHANNEL_EDIT "gimp-channel-edit"
#define GIMP_HELP_QMASK "gimp-qmask" #define GIMP_HELP_QUICK_MASK "gimp-quick-mask"
#define GIMP_HELP_QMASK_TOGGLE "gimp-qmask-toggle" #define GIMP_HELP_QUICK_MASK_TOGGLE "gimp-quick-mask-toggle"
#define GIMP_HELP_QMASK_INVERT "gimp-qmask-invert" #define GIMP_HELP_QUICK_MASK_INVERT "gimp-quick-mask-invert"
#define GIMP_HELP_QMASK_EDIT "gimp-qmask-edit" #define GIMP_HELP_QUICK_MASK_EDIT "gimp-quick-mask-edit"
#define GIMP_HELP_PATH_DIALOG "gimp-path-dialog" #define GIMP_HELP_PATH_DIALOG "gimp-path-dialog"
#define GIMP_HELP_PATH_NEW "gimp-path-new" #define GIMP_HELP_PATH_NEW "gimp-path-new"

12
libgimpwidgets/gimpstock.c
View File

@ -231,8 +231,10 @@ static GtkStockItem gimp_stock_items[] =
{ GIMP_STOCK_SELECTION_BORDER, NULL, 0, 0, LIBGIMP_DOMAIN }, { GIMP_STOCK_SELECTION_BORDER, NULL, 0, 0, LIBGIMP_DOMAIN },
{ GIMP_STOCK_NAVIGATION, NULL, 0, 0, LIBGIMP_DOMAIN }, { GIMP_STOCK_NAVIGATION, NULL, 0, 0, LIBGIMP_DOMAIN },
{ GIMP_STOCK_QMASK_OFF, NULL, 0, 0, LIBGIMP_DOMAIN }, { GIMP_STOCK_QUICK_MASK_OFF, NULL, 0, 0, LIBGIMP_DOMAIN },
{ GIMP_STOCK_QMASK_ON, NULL, 0, 0, LIBGIMP_DOMAIN }, { GIMP_STOCK_QUICK_MASK_ON, NULL, 0, 0, LIBGIMP_DOMAIN },
{ "gimp-qmask-off", /* compat */ NULL, 0, 0, LIBGIMP_DOMAIN },
{ "gimp-qmask-on", /* compat */ NULL, 0, 0, LIBGIMP_DOMAIN },
{ GIMP_STOCK_LIST, NULL, 0, 0, LIBGIMP_DOMAIN }, { GIMP_STOCK_LIST, NULL, 0, 0, LIBGIMP_DOMAIN },
{ GIMP_STOCK_GRID, NULL, 0, 0, LIBGIMP_DOMAIN }, { GIMP_STOCK_GRID, NULL, 0, 0, LIBGIMP_DOMAIN },
@ -512,8 +514,10 @@ gimp_stock_menu_pixbufs[] =
{ GIMP_STOCK_SELECTION_BORDER, stock_selection_border_16 }, { GIMP_STOCK_SELECTION_BORDER, stock_selection_border_16 },
{ GIMP_STOCK_NAVIGATION, stock_navigation_16 }, { GIMP_STOCK_NAVIGATION, stock_navigation_16 },
{ GIMP_STOCK_QMASK_OFF, stock_qmask_off_16 }, { GIMP_STOCK_QUICK_MASK_OFF, stock_quick_mask_off_16 },
{ GIMP_STOCK_QMASK_ON, stock_qmask_on_16 }, { GIMP_STOCK_QUICK_MASK_ON, stock_quick_mask_on_16 },
{ "gimp-qmask-off", /* compat */ stock_quick_mask_off_16 },
{ "gimp-qmask-on", /* compat */ stock_quick_mask_on_16 },
{ GIMP_STOCK_LIST, stock_list_16 }, { GIMP_STOCK_LIST, stock_list_16 },
{ GIMP_STOCK_GRID, stock_grid_16 }, { GIMP_STOCK_GRID, stock_grid_16 },

9
libgimpwidgets/gimpstock.h
View File

@ -185,8 +185,13 @@ G_BEGIN_DECLS
#define GIMP_STOCK_SELECTION_BORDER "gimp-selection-border" #define GIMP_STOCK_SELECTION_BORDER "gimp-selection-border"
#define GIMP_STOCK_NAVIGATION "gimp-navigation" #define GIMP_STOCK_NAVIGATION "gimp-navigation"
#define GIMP_STOCK_QMASK_OFF "gimp-qmask-off" #define GIMP_STOCK_QUICK_MASK_OFF "gimp-quick-mask-off"
#define GIMP_STOCK_QMASK_ON "gimp-qmask-on" #define GIMP_STOCK_QUICK_MASK_ON "gimp-quick-mask-on"
#ifndef GIMP_DISABLE_DEPRECATED
#define GIMP_STOCK_QMASK_OFF "gimp-quick-mask-off"
#define GIMP_STOCK_QMASK_ON "gimp-quick-mask-on"
#endif /* GIMP_DISABLE_DEPRECATED */
#define GIMP_STOCK_HISTOGRAM "gimp-histogram" #define GIMP_STOCK_HISTOGRAM "gimp-histogram"
#define GIMP_STOCK_HISTOGRAM_LINEAR "gimp-histogram-linear" #define GIMP_STOCK_HISTOGRAM_LINEAR "gimp-histogram-linear"

2
menus/Makefile.am
View File

@ -26,7 +26,7 @@ menudata_DATA = \
palette-editor-menu.xml \ palette-editor-menu.xml \
palettes-menu.xml \ palettes-menu.xml \
patterns-menu.xml \ patterns-menu.xml \
qmask-menu.xml \ quick-mask-menu.xml \
sample-point-editor-menu.xml \ sample-point-editor-menu.xml \
selection-editor-menu.xml \ selection-editor-menu.xml \
templates-menu.xml \ templates-menu.xml \

2
menus/image-menu.xml.in
View File

@ -204,7 +204,7 @@
<menuitem action="select-border" /> <menuitem action="select-border" />
</placeholder> </placeholder>
<separator /> <separator />
<menuitem action="qmask-toggle" /> <menuitem action="quick-mask-toggle" />
<menuitem action="select-save" /> <menuitem action="select-save" />
<menuitem action="vectors-selection-to-vectors-short" /> <menuitem action="vectors-selection-to-vectors-short" />
<separator /> <separator />

13
menus/qmask-menu.xml
View File

@ -1,13 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE ui SYSTEM "gtkuimanager.dtd">
<ui>
<popup action="qmask-popup">
<menuitem action="qmask-toggle" />
<separator />
<menuitem action="qmask-invert-on" />
<menuitem action="qmask-invert-off" />
<separator />
<menuitem action="qmask-configure" />
</popup>
</ui>

13
menus/quick-mask-menu.xml Normal file
View File

@ -0,0 +1,13 @@
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE ui SYSTEM "gtkuimanager.dtd">
<ui>
<popup action="quick-mask-popup">
<menuitem action="quick-mask-toggle" />
<separator />
<menuitem action="quick-mask-invert-on" />
<menuitem action="quick-mask-invert-off" />
<separator />
<menuitem action="quick-mask-configure" />
</popup>
</ui>

4
themes/Default/images/Makefile.am
View File

@ -95,8 +95,8 @@ STOCK_MENU_IMAGES = \
stock-plugin-16.png \ stock-plugin-16.png \
stock-portrait-16.png \ stock-portrait-16.png \
stock-print-resolution-16.png \ stock-print-resolution-16.png \
stock-qmask-off-16.png \ stock-quick-mask-off-16.png \
stock-qmask-on-16.png \ stock-quick-mask-on-16.png \
stock-reshow-filter-16.png \ stock-reshow-filter-16.png \
stock-resize-16.png \ stock-resize-16.png \
stock-rotate-180-16.png \ stock-rotate-180-16.png \

0
themes/Default/images/stock-qmask-off-16.png → themes/Default/images/stock-quick-mask-off-16.png
View File

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 200 B

After

Width:  |  Height:  |  Size: 200 B

0
themes/Default/images/stock-qmask-on-16.png → themes/Default/images/stock-quick-mask-on-16.png
View File

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 188 B

After

Width:  |  Height:  |  Size: 188 B