Attachment #292305 for bug #385121

Lines 38-44 Link Here

(-)ogmrip-0.13.6.orig/configure.in (-1 lines)
38	AM_MAINTAINER_MODE	38	AM_MAINTAINER_MODE
39		39
40	CFLAGS="$CFLAGS -g -I/usr/local/include -I.. -Wall -D_FORTIFY_SOURCE=2"	40	CFLAGS="$CFLAGS -g -I/usr/local/include -I.. -Wall -D_FORTIFY_SOURCE=2"
41	CFLAGS="$CFLAGS -DG_DISABLE_DEPRECATED -DGDK_PIXBUF_DISABLE_DEPRECATED -DGTK_DISABLE_DEPRECATED"
42	CFLAGS="$CFLAGS -DG_DISABLE_SINGLE_INCLUDES -DGTK_DISABLE_SINGLE_INCLUDES"	41	CFLAGS="$CFLAGS -DG_DISABLE_SINGLE_INCLUDES -DGTK_DISABLE_SINGLE_INCLUDES"
43		42
44	CPPFLAGS="$CPPFLAGS -I/usr/local/include -I.. -Wall -D_FORTIFY_SOURCE=2"	43	CPPFLAGS="$CPPFLAGS -I/usr/local/include -I.. -Wall -D_FORTIFY_SOURCE=2"




  return reader;
}

static const gchar *
dvd_reader_get_id (dvd_reader_t *reader)
{
  static gchar str[33];

 *
 * Returns: The label of the DVD, or NULL
 */
const gchar *
ogmdvd_disc_get_label (OGMDvdDisc *disc)
{
  g_return_val_if_fail (disc != NULL, NULL);

 *
 * Returns: The identifier, or NULL
 */
const gchar *
ogmdvd_disc_get_id (OGMDvdDisc *disc)
{
  g_return_val_if_fail (disc != NULL, NULL);

 *
 * Returns: The device of the DVD.
 */
const gchar *
ogmdvd_disc_get_device (OGMDvdDisc *disc)
{
  g_return_val_if_fail (disc != NULL, NULL);

Lines 67-77 Link Here

(-)ogmrip-0.13.6.orig/libogmdvd/ogmdvd-disc.h (-3 / +3 lines)
67		67
68	void ogmdvd_disc_ref (OGMDvdDisc *disc);	68	void ogmdvd_disc_ref (OGMDvdDisc *disc);
69	void ogmdvd_disc_unref (OGMDvdDisc *disc);	69	void ogmdvd_disc_unref (OGMDvdDisc *disc);
70	G_CONST_RETURN	70	const
71	gchar * ogmdvd_disc_get_label (OGMDvdDisc *disc);	71	gchar * ogmdvd_disc_get_label (OGMDvdDisc *disc);
72	G_CONST_RETURN	72	const
73	gchar * ogmdvd_disc_get_id (OGMDvdDisc *disc);	73	gchar * ogmdvd_disc_get_id (OGMDvdDisc *disc);
74	G_CONST_RETURN	74	const
75	gchar * ogmdvd_disc_get_device (OGMDvdDisc *disc);	75	gchar * ogmdvd_disc_get_device (OGMDvdDisc *disc);
76	gint64 ogmdvd_disc_get_vmg_size (OGMDvdDisc *disc);	76	gint64 ogmdvd_disc_get_vmg_size (OGMDvdDisc *disc);
77	gint ogmdvd_disc_get_n_titles (OGMDvdDisc *disc);	77	gint ogmdvd_disc_get_n_titles (OGMDvdDisc *disc);




 *
 * Returns: A constant string, or NULL
 */
const gchar *
ogmdvd_get_video_format_label (gint format)
{
  static const gchar *video_format[] = 

 *
 * Returns: A constant string, or NULL
 */
const gchar *
ogmdvd_get_display_aspect_label (gint aspect)
{
  static gchar *display_aspect[] =

 *
 * Returns: A constant string, or NULL
 */
const gchar *
ogmdvd_get_audio_format_label (gint format)
{
  static gchar *audio_format[] =

 *
 * Returns: A constant string, or NULL
 */
const gchar *
ogmdvd_get_audio_channels_label (gint channels)
{
  static gchar *audio_channels[] =

 *
 * Returns: A constant string, or NULL
 */
const gchar *
ogmdvd_get_audio_quantization_label (gint quantization)
{
  static gchar *audio_quantization[] = 

 *
 * Returns: A constant string, or NULL
 */
const gchar *
ogmdvd_get_audio_content_label (gint content)
{
  static gchar *audio_content[] = 

 *
 * Returns: A constant string, or NULL
 */
const gchar *
ogmdvd_get_subp_content_label (gint content)
{
  static gchar *subp_content[] = 

 *
 * Returns: A constant string, or NULL
 */
const gchar *
ogmdvd_get_language_label (gint code)
{
  const gchar *lang;

 *
 * Returns: A constant string, or NULL
 */
const gchar *
ogmdvd_get_language_iso639_1 (gint code)
{
  static gchar lang[3];

 *
 * Returns: A constant string, or NULL
 */
const gchar *
ogmdvd_get_language_iso639_2 (gint code)
{
  const gchar *lang;





G_BEGIN_DECLS

const gchar * ogmdvd_get_video_format_label       (gint format);
const gchar * ogmdvd_get_display_aspect_label     (gint aspect);
const gchar * ogmdvd_get_audio_format_label       (gint format);
const gchar * ogmdvd_get_audio_channels_label     (gint channels);
const gchar * ogmdvd_get_audio_quantization_label (gint quantization);
const gchar * ogmdvd_get_audio_content_label      (gint content);
const gchar * ogmdvd_get_subp_content_label       (gint content);
const gchar * ogmdvd_get_language_label           (gint code);
const gchar * ogmdvd_get_language_iso639_1        (gint code);
const gchar * ogmdvd_get_language_iso639_2        (gint code);

G_END_DECLS


Lines 437-443 Link Here

(-)ogmrip-0.13.6.orig/libogmdvd/ogmdvd-title.c (-1 / +1 lines)
437	*	437	*
438	* Returns: a constant array of 16 integers, or NULL	438	* Returns: a constant array of 16 integers, or NULL
439	*/	439	*/
440	G_CONST_RETURN guint *	440	const guint *
441	ogmdvd_title_get_palette (OGMDvdTitle *title)	441	ogmdvd_title_get_palette (OGMDvdTitle *title)
442	{	442	{
443	g_return_val_if_fail (title != NULL, NULL);	443	g_return_val_if_fail (title != NULL, NULL);

Lines 54-60 Link Here

(-)ogmrip-0.13.6.orig/libogmdvd/ogmdvd-title.h (-1 / +1 lines)
54	void ogmdvd_title_get_aspect_ratio (OGMDvdTitle *title,	54	void ogmdvd_title_get_aspect_ratio (OGMDvdTitle *title,
55	guint *numerator,	55	guint *numerator,
56	guint *denominator);	56	guint *denominator);
57	G_CONST_RETURN	57	const
58	guint * ogmdvd_title_get_palette (OGMDvdTitle *title);	58	guint * ogmdvd_title_get_palette (OGMDvdTitle *title);
59	gint ogmdvd_title_get_n_angles (OGMDvdTitle *title);	59	gint ogmdvd_title_get_n_angles (OGMDvdTitle *title);
60	gint ogmdvd_title_get_n_chapters (OGMDvdTitle *title);	60	gint ogmdvd_title_get_n_chapters (OGMDvdTitle *title);

Lines 465-471 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-audio-codec.c (-1 / +1 lines)
465	*	465	*
466	* Returns: the track name	466	* Returns: the track name
467	*/	467	*/
468	G_CONST_RETURN gchar *	468	const gchar *
469	ogmrip_audio_codec_get_label (OGMRipAudioCodec *audio)	469	ogmrip_audio_codec_get_label (OGMRipAudioCodec *audio)
470	{	470	{
471	g_return_val_if_fail (OGMRIP_IS_AUDIO_CODEC (audio), NULL);	471	g_return_val_if_fail (OGMRIP_IS_AUDIO_CODEC (audio), NULL);

Lines 71-77 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-audio-codec.h (-1 / +1 lines)
71	gint ogmrip_audio_codec_get_sample_rate (OGMRipAudioCodec *audio);	71	gint ogmrip_audio_codec_get_sample_rate (OGMRipAudioCodec *audio);
72	void ogmrip_audio_codec_set_label (OGMRipAudioCodec *audio,	72	void ogmrip_audio_codec_set_label (OGMRipAudioCodec *audio,
73	const gchar *label);	73	const gchar *label);
74	G_CONST_RETURN	74	const
75	gchar * ogmrip_audio_codec_get_label (OGMRipAudioCodec *audio);	75	gchar * ogmrip_audio_codec_get_label (OGMRipAudioCodec *audio);
76	gint ogmrip_audio_codec_get_samples_per_frame (OGMRipAudioCodec *audio);	76	gint ogmrip_audio_codec_get_samples_per_frame (OGMRipAudioCodec *audio);
77		77

Lines 205-211 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-chapters.c (-1 / +1 lines)
205	*	205	*
206	* Returns: The label	206	* Returns: The label
207	*/	207	*/
208	G_CONST_RETURN gchar *	208	const gchar *
209	ogmrip_chapters_get_label (OGMRipChapters *chapters, guint n)	209	ogmrip_chapters_get_label (OGMRipChapters *chapters, guint n)
210	{	210	{
211	g_return_val_if_fail (OGMRIP_IS_CHAPTERS (chapters), NULL);	211	g_return_val_if_fail (OGMRIP_IS_CHAPTERS (chapters), NULL);

Lines 48-54 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-chapters.h (-1 / +1 lines)
48	GType ogmrip_chapters_get_type (void);	48	GType ogmrip_chapters_get_type (void);
49	OGMJobSpawn * ogmrip_chapters_new (OGMDvdTitle *title,	49	OGMJobSpawn * ogmrip_chapters_new (OGMDvdTitle *title,
50	const gchar *output);	50	const gchar *output);
51	G_CONST_RETURN	51	const
52	gchar * ogmrip_chapters_get_label (OGMRipChapters *chapters,	52	gchar * ogmrip_chapters_get_label (OGMRipChapters *chapters,
53	guint n);	53	guint n);
54	void ogmrip_chapters_set_label (OGMRipChapters *chapters,	54	void ogmrip_chapters_set_label (OGMRipChapters *chapters,

Lines 294-300 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-codec.c (-1 / +1 lines)
294	*	294	*
295	* Returns: the filename, or NULL	295	* Returns: the filename, or NULL
296	*/	296	*/
297	G_CONST_RETURN gchar *	297	const gchar *
298	ogmrip_codec_get_output (OGMRipCodec *codec)	298	ogmrip_codec_get_output (OGMRipCodec *codec)
299	{	299	{
300	g_return_val_if_fail (OGMRIP_IS_CODEC (codec), NULL);	300	g_return_val_if_fail (OGMRIP_IS_CODEC (codec), NULL);

Lines 53-59 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-codec.h (-1 / +1 lines)
53	};	53	};
54		54
55	GType ogmrip_codec_get_type (void);	55	GType ogmrip_codec_get_type (void);
56	G_CONST_RETURN	56	const
57	gchar * ogmrip_codec_get_output (OGMRipCodec *codec);	57	gchar * ogmrip_codec_get_output (OGMRipCodec *codec);
58	void ogmrip_codec_set_output (OGMRipCodec *codec,	58	void ogmrip_codec_set_output (OGMRipCodec *codec,
59	const gchar *output);	59	const gchar *output);




 *
 * Returns: The filename, or NULL
 */
const gchar *
ogmrip_container_get_output (OGMRipContainer *container)
{
  g_return_val_if_fail (OGMRIP_IS_CONTAINER (container), NULL);

 *
 * Returns: The label, or NULL
 */
const gchar *
ogmrip_container_get_label (OGMRipContainer *container)
{
  g_return_val_if_fail (OGMRIP_IS_CONTAINER (container), NULL);

 *
 * Returns: The FourCC, or NULL
 */
const gchar *
ogmrip_container_get_fourcc (OGMRipContainer *container)
{
  g_return_val_if_fail (OGMRIP_IS_CONTAINER (container), NULL);




void               ogmrip_container_set_options          (OGMRipContainer          *container,
                                                          const gchar              *section);

const
gchar *            ogmrip_container_get_output           (OGMRipContainer          *container);
void               ogmrip_container_set_output           (OGMRipContainer          *container,
                                                          const gchar              *output);
const
gchar *            ogmrip_container_get_label            (OGMRipContainer          *container);
void               ogmrip_container_set_label            (OGMRipContainer          *container,
                                                          const gchar              *label);

const
gchar *            ogmrip_container_get_fourcc           (OGMRipContainer          *container);
void               ogmrip_container_set_fourcc           (OGMRipContainer          *container,
                                                          const gchar              *fourcc);

Lines 217-223 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-edl.c (-1 / +1 lines)
217	*	217	*
218	* Returns: The filename	218	* Returns: The filename
219	*/	219	*/
220	G_CONST_RETURN gchar *	220	const gchar *
221	ogmrip_edl_get_filename (OGMRipEdl *edl)	221	ogmrip_edl_get_filename (OGMRipEdl *edl)
222	{	222	{
223	g_return_val_if_fail (edl != NULL, NULL);	223	g_return_val_if_fail (edl != NULL, NULL);

Lines 56-62 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-edl.h (-1 / +1 lines)
56	void ogmrip_edl_ref (OGMRipEdl *edl);	56	void ogmrip_edl_ref (OGMRipEdl *edl);
57	void ogmrip_edl_unref (OGMRipEdl *edl);	57	void ogmrip_edl_unref (OGMRipEdl *edl);
58		58
59	G_CONST_RETURN	59	const
60	gchar * ogmrip_edl_get_filename (OGMRipEdl *edl);	60	gchar * ogmrip_edl_get_filename (OGMRipEdl *edl);
61		61
62	void ogmrip_edl_add (OGMRipEdl *edl,	62	void ogmrip_edl_add (OGMRipEdl *edl,




  return data1->nr - data2->nr;
}

static const gchar *
ogmrip_encoding_get_device (OGMRipEncoding *encoding)
{
  g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);

 *
 * Returns: The id, or NULL
 */
const gchar *
ogmrip_encoding_get_id (OGMRipEncoding *encoding)
{
  g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);

 *
 * Returns: The profile' section, or NULL
 */
const gchar *
ogmrip_encoding_get_profile (OGMRipEncoding *encoding)
{
  g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);

 *
 * Returns: The name of the encoding, or NULL
 */
const gchar *
ogmrip_encoding_get_label (OGMRipEncoding *encoding)
{
  g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);

 *
 * Returns: The name of the chapter, or NULL
 */
const gchar *
ogmrip_encoding_get_chapter_label (OGMRipEncoding *encoding, guint nr)
{
  OGMRipChapterData *data;

 *
 * Returns: The output filename, or NULL
 */
const gchar *
ogmrip_encoding_get_filename (OGMRipEncoding *encoding)
{
  g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);

 *
 * Returns: The log filename, or NULL
 */
const gchar *
ogmrip_encoding_get_logfile (OGMRipEncoding *encoding)
{
  g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);

 *
 * Returns: The FourCC, or NULL
 */
const gchar *
ogmrip_encoding_get_fourcc (OGMRipEncoding *encoding)
{
  g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);





guint32             ogmrip_encoding_get_flags              (OGMRipEncoding          *encoding);

const
gchar *             ogmrip_encoding_get_id                 (OGMRipEncoding          *encoding);
OGMDvdTitle *       ogmrip_encoding_get_title              (OGMRipEncoding          *encoding);

const
gchar *             ogmrip_encoding_get_profile            (OGMRipEncoding          *encoding);
void                ogmrip_encoding_set_profile            (OGMRipEncoding          *encoding,
                                                            const gchar             *profile);

const
gchar *             ogmrip_encoding_get_label              (OGMRipEncoding          *encoding);
void                ogmrip_encoding_set_label              (OGMRipEncoding          *encoding,
                                                            const gchar             *label);

gint                ogmrip_encoding_get_chapters_language  (OGMRipEncoding          *encoding);
void                ogmrip_encoding_set_chapters_language  (OGMRipEncoding          *encoding,
                                                            guint                   language);
const
gchar *             ogmrip_encoding_get_chapter_label      (OGMRipEncoding          *encoding,
                                                            guint                   nr);
void                ogmrip_encoding_set_chapter_label      (OGMRipEncoding          *encoding,

gboolean            ogmrip_encoding_get_keep_tmp_files     (OGMRipEncoding          *encoding);
void                ogmrip_encoding_set_keep_tmp_files     (OGMRipEncoding          *encoding,
                                                            gboolean                keep_tmp_files);
const
gchar *             ogmrip_encoding_get_filename           (OGMRipEncoding          *encoding);
void                ogmrip_encoding_set_filename           (OGMRipEncoding          *encoding,
                                                            const gchar             *filename);
const
gchar *             ogmrip_encoding_get_logfile            (OGMRipEncoding          *encoding);

gint                ogmrip_encoding_get_threads            (OGMRipEncoding          *encoding);

gboolean            ogmrip_encoding_set_container_type     (OGMRipEncoding          *encoding,
                                                            GType                   type,
                                                            GError                  **error);
const
gchar *             ogmrip_encoding_get_fourcc             (OGMRipEncoding          *encoding);
void                ogmrip_encoding_set_fourcc             (OGMRipEncoding          *encoding,
                                                            const gchar             *fourcc);

Lines 51-57 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-fs.c (-2 / +2 lines)
51	*	51	*
52	* Returns: The temporaty directory	52	* Returns: The temporaty directory
53	*/	53	*/
54	G_CONST_RETURN gchar *	54	const gchar *
55	ogmrip_fs_get_tmp_dir (void)	55	ogmrip_fs_get_tmp_dir (void)
56	{	56	{
57	if (!ogmrip_tmp_dir)	57	if (!ogmrip_tmp_dir)
Lines 618-624 Link Here
618	*	618	*
619	* Returns: The extension, or NULL	619	* Returns: The extension, or NULL
620	*/	620	*/
621	G_CONST_RETURN gchar *	621	const gchar *
622	ogmrip_fs_get_extension (const gchar *filename)	622	ogmrip_fs_get_extension (const gchar *filename)
623	{	623	{
624	gchar *dot;	624	gchar *dot;

Lines 30-36 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-fs.h (-2 / +2 lines)
30	#define g_chdir chdir	30	#define g_chdir chdir
31	#endif	31	#endif
32		32
33	G_CONST_RETURN	33	const
34	gchar * ogmrip_fs_get_tmp_dir (void);	34	gchar * ogmrip_fs_get_tmp_dir (void);
35	void ogmrip_fs_set_tmp_dir (const gchar *dir);	35	void ogmrip_fs_set_tmp_dir (const gchar *dir);
36		36
Lines 71-77 Link Here
71		71
72	gchar * ogmrip_fs_get_full_path (const gchar *filename);	72	gchar * ogmrip_fs_get_full_path (const gchar *filename);
73		73
74	G_CONST_RETURN	74	const
75	gchar * ogmrip_fs_get_extension (const gchar *filename);	75	gchar * ogmrip_fs_get_extension (const gchar *filename);
76	gchar * ogmrip_fs_set_extension (const gchar *filename,	76	gchar * ogmrip_fs_set_extension (const gchar *filename,
77	const gchar *extension);	77	const gchar *extension);

Lines 135-141 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-lavc.c (-1 / +1 lines)
135	return CLAMP (quantizer, 2, 31);	135	return CLAMP (quantizer, 2, 31);
136	}	136	}
137		137
138	static G_CONST_RETURN gchar *	138	static const gchar *
139	ogmrip_lavc_get_codec (OGMRipLavc *lavc)	139	ogmrip_lavc_get_codec (OGMRipLavc *lavc)
140	{	140	{
141	OGMRipLavcClass *klass;	141	OGMRipLavcClass *klass;

Lines 69-75 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-lavc.h (-1 / +1 lines)
69	OGMRipVideoCodecClass parent_class;	69	OGMRipVideoCodecClass parent_class;
70		70
71	/* vtable */	71	/* vtable */
72	G_CONST_RETURN gchar * (* get_codec) (void);	72	const gchar * (* get_codec) (void);
73	};	73	};
74		74
75	/**	75	/**




  return NULL;
}

static const gchar *
ogmrip_plugin_get_codec_name (GSList *list, GType type)
{
  OGMRipPlugin *plugin;

 *
 * Returns: The name of the container, or NULL 
 */
const gchar *
ogmrip_plugin_get_container_name (GType container)
{
  OGMRipContainerPlugin *plugin;

 *
 * Returns: The name of the video codec, or NULL 
 */
const gchar *
ogmrip_plugin_get_video_codec_name (GType codec)
{
  g_return_val_if_fail (g_type_is_a (codec, OGMRIP_TYPE_VIDEO_CODEC), NULL);

 *
 * Returns: The name of the audio codec, or NULL 
 */
const gchar *
ogmrip_plugin_get_audio_codec_name (GType codec)
{
  g_return_val_if_fail (g_type_is_a (codec, OGMRIP_TYPE_AUDIO_CODEC), NULL);

 *
 * Returns: The name of the subtitle codec, or NULL 
 */
const gchar *
ogmrip_plugin_get_subp_codec_name (GType codec)
{
  g_return_val_if_fail (g_type_is_a (codec, OGMRIP_TYPE_SUBP_CODEC), NULL);




GType     ogmrip_plugin_get_nth_container       (guint n);
GType     ogmrip_plugin_get_container_by_name   (const gchar *name);
gint      ogmrip_plugin_get_container_index     (GType container);
const
gchar *   ogmrip_plugin_get_container_name      (GType container);
gboolean  ogmrip_plugin_get_container_bframes   (GType container);
gint      ogmrip_plugin_get_container_max_audio (GType container);

GType     ogmrip_plugin_get_nth_video_codec     (guint n);
GType     ogmrip_plugin_get_video_codec_by_name (const gchar *name);
gint      ogmrip_plugin_get_video_codec_index   (GType codec);
const
gchar *   ogmrip_plugin_get_video_codec_name    (GType codec);
gint      ogmrip_plugin_get_video_codec_format  (GType codec);
gint      ogmrip_plugin_get_video_codec_passes  (GType codec);

GType     ogmrip_plugin_get_nth_audio_codec     (guint n);
GType     ogmrip_plugin_get_audio_codec_by_name (const gchar *name);
gint      ogmrip_plugin_get_audio_codec_index   (GType codec);
const
gchar *   ogmrip_plugin_get_audio_codec_name    (GType codec);
gint      ogmrip_plugin_get_audio_codec_format  (GType codec);
GModule * ogmrip_plugin_get_audio_codec_module  (GType codec);

GType     ogmrip_plugin_get_nth_subp_codec     (guint n);
GType     ogmrip_plugin_get_subp_codec_by_name (const gchar *name);
gint      ogmrip_plugin_get_subp_codec_index   (GType codec);
const
gchar *   ogmrip_plugin_get_subp_codec_name    (GType codec);
gint      ogmrip_plugin_get_subp_codec_format  (GType codec);
gboolean  ogmrip_plugin_get_subp_codec_text    (GType codec);

Lines 347-353 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-subp-codec.c (-1 / +1 lines)
347	*	347	*
348	* Returns: the track name	348	* Returns: the track name
349	*/	349	*/
350	G_CONST_RETURN gchar *	350	const gchar *
351	ogmrip_subp_codec_get_label (OGMRipSubpCodec *subp)	351	ogmrip_subp_codec_get_label (OGMRipSubpCodec *subp)
352	{	352	{
353	g_return_val_if_fail (OGMRIP_IS_SUBP_CODEC (subp), NULL);	353	g_return_val_if_fail (OGMRIP_IS_SUBP_CODEC (subp), NULL);

Lines 62-68 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-subp-codec.h (-1 / +1 lines)
62	gint ogmrip_subp_codec_get_newline (OGMRipSubpCodec *subp);	62	gint ogmrip_subp_codec_get_newline (OGMRipSubpCodec *subp);
63	void ogmrip_subp_codec_set_label (OGMRipSubpCodec *subp,	63	void ogmrip_subp_codec_set_label (OGMRipSubpCodec *subp,
64	const gchar *label);	64	const gchar *label);
65	G_CONST_RETURN	65	const
66	gchar * ogmrip_subp_codec_get_label (OGMRipSubpCodec *subp);	66	gchar * ogmrip_subp_codec_get_label (OGMRipSubpCodec *subp);
67		67
68	G_END_DECLS	68	G_END_DECLS

Lines 207-213 Link Here

(-)ogmrip-0.13.6.orig/libogmrip-gtk/ogmrip-source-chooser-widget.c (+9 lines)
207	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);	207	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
208	gtk_widget_show (label);	208	gtk_widget_show (label);
209		209
		210	#if GTK_CHECK_VERSION(2,24,0)
		211	combo = gtk_combo_box_text_new ();
		212	#else
210	combo = gtk_combo_box_new_text ();	213	combo = gtk_combo_box_new_text ();
		214	#endif
		215
211	gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0);	216	gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0);
212	gtk_widget_show (combo);	217	gtk_widget_show (combo);
213		218
Lines 231-237 Link Here
231	{	236	{
232	str = g_strdup_printf ("%s (%s)", ogmdvd_languages[i][OGMDVD_LANGUAGE_NAME],	237	str = g_strdup_printf ("%s (%s)", ogmdvd_languages[i][OGMDVD_LANGUAGE_NAME],
233	ogmdvd_languages[i][OGMDVD_LANGUAGE_ISO639_1]);	238	ogmdvd_languages[i][OGMDVD_LANGUAGE_ISO639_1]);
		239	#if GTK_CHECK_VERSION(2,24,0)
		240	gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), str);
		241	#else
234	gtk_combo_box_append_text (GTK_COMBO_BOX (combo), str);	242	gtk_combo_box_append_text (GTK_COMBO_BOX (combo), str);
		243	#endif
235	g_free (str);	244	g_free (str);
236		245
237	if (strncmp (ogmdvd_languages[i][OGMDVD_LANGUAGE_ISO639_1], lang, 2) == 0)	246	if (strncmp (ogmdvd_languages[i][OGMDVD_LANGUAGE_ISO639_1], lang, 2) == 0)




      NULL);
  gtk_window_set_title (GTK_WINDOW (dialog), _("X264 Options"));
  gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
#if !GTK_CHECK_VERSION(2,22,0)
  gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
#endif
  gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
  gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
  gtk_window_set_icon_from_stock (GTK_WINDOW (dialog), GTK_STOCK_PREFERENCES);

  gtk_widget_set_sensitive (dialog->me_combo, x264_have_me);

  if (x264_have_me_tesa)
  {
    GtkTreeModel *model;
    GtkTreeIter iter;

    model = gtk_combo_box_get_model (GTK_COMBO_BOX (dialog->me_combo));
    gtk_list_store_append (GTK_LIST_STORE (model), &iter);
    gtk_list_store_set (GTK_LIST_STORE (model), &iter,
        0, _("Transformed Exhaustive search (tesa - even slower)"), -1);
  }

  dialog->merange_spin = glade_xml_get_widget (xml, "merange-spin");
  gtk_widget_set_sensitive (dialog->merange_spin, x264_have_me);

Lines 165-171 Link Here

(-)ogmrip-0.13.6.orig/libogmrip-gtk/ogmrip-xvid-options.c (+2 lines)
165	return;	165	return;
166	}	166	}
167		167
		168	#if !GTK_CHECK_VERSION(2,22,0)
168	gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);	169	gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
		170	#endif
169	gtk_dialog_add_buttons (GTK_DIALOG (dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL);	171	gtk_dialog_add_buttons (GTK_DIALOG (dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL);
170		172
171	gtk_window_set_title (GTK_WINDOW (dialog), _("XviD Options"));	173	gtk_window_set_title (GTK_WINDOW (dialog), _("XviD Options"));




}

static void
ogmrip_crop_dialog_scale_button_released (OGMRipCropDialog *dialog, GdkEventButton *event, GtkWidget *scale)
{
  if (!event || event->button == 1)
  {
    gulong frame;
    gchar *text;

    frame = (guint) gtk_range_get_value (GTK_RANGE (scale));
    text = g_strdup_printf (_("Frame %lu of %lu"), frame, dialog->priv->length);
    gtk_label_set_text (GTK_LABEL (dialog->priv->label), text);
    g_free (text);

    ogmrip_crop_dialog_grab_frame (dialog, frame);
  }
}

G_DEFINE_TYPE (OGMRipCropDialog, ogmrip_crop_dialog, GTK_TYPE_DIALOG)

  dialog->priv->label = glade_xml_get_widget (xml, "frame-label");

  dialog->priv->scale = glade_xml_get_widget (xml, "frame-scale");
  g_signal_connect_swapped (dialog->priv->scale, "button-release-event",
      G_CALLBACK (ogmrip_crop_dialog_scale_button_released), dialog);
      G_CALLBACK (ogmrip_crop_dialog_scale_value_changed), dialog);

  g_object_unref (xml);
}

  frame = g_random_int_range (1, dialog->priv->length);
  gtk_range_set_value (GTK_RANGE (dialog->priv->scale), frame);

  ogmrip_crop_dialog_scale_button_released (dialog, NULL, dialog->priv->scale);

  return GTK_WIDGET (dialog);
}


Lines 211-217 Link Here

(-)ogmrip-0.13.6.orig/src/ogmrip-pref-dialog.c (+2 lines)
211	gtk_dialog_add_buttons (GTK_DIALOG (dialog),	211	gtk_dialog_add_buttons (GTK_DIALOG (dialog),
212	GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,	212	GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
213	NULL);	213	NULL);
		214	#if !GTK_CHECK_VERSION(2,22,0)
214	gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);	215	gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
		216	#endif
215	gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);	217	gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
216	gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);	218	gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
217	gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);	219	gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);




static void
ogmrip_profile_editor_dialog_video_codec_combo_changed (OGMRipProfileEditorDialog *dialog, GtkWidget *combo)
{
  GType codec;

  codec = ogmrip_combo_box_get_active_video_codec (GTK_COMBO_BOX (combo));
  if (codec != G_TYPE_NONE)
  {
    GType codec;
    GtkTreeModel *model;
    GtkTreeIter iter;
    gboolean exists;
    gint active;
    gchar *name;

    model = gtk_combo_box_get_model (GTK_COMBO_BOX (dialog->priv->video_preset_combo));
    gtk_tree_model_get (model, &iter, 1, &name, -1);

    if (gtk_tree_model_iter_nth_child (model, &iter, NULL, OGMRIP_VIDEO_PRESET_USER))
      gtk_list_store_remove (GTK_LIST_STORE (model), &iter);

    gtk_combo_box_remove_text (GTK_COMBO_BOX (dialog->priv->video_preset_combo), OGMRIP_VIDEO_PRESET_USER);

    exists = ogmrip_options_plugin_exists (codec);
    if (exists)
    {
      gtk_list_store_append (GTK_LIST_STORE (model), &iter);
      gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, _("User"), -1);
    }

    active = gtk_combo_box_get_active (GTK_COMBO_BOX (dialog->priv->video_preset_combo));
    

static void
ogmrip_profile_editor_dialog_audio_codec_combo_changed (OGMRipProfileEditorDialog *dialog, GtkWidget *combo)
{
  if (dialog->priv->audio_options_button)

  if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter))
  {
    GType codec;
    GtkTreeModel *model;
    gchar *name;

    codec = ogmrip_combo_box_get_active_audio_codec (GTK_COMBO_BOX (combo));
    if (codec != G_TYPE_NONE)

    codec = ogmrip_profile_editor_dialog_get_audio_codec_type (dialog, name);
    g_free (name);

    if (dialog->priv->audio_options_button)
      gtk_widget_set_sensitive (dialog->priv->audio_options_button,
          ogmrip_options_plugin_exists (codec));
  }

static void
ogmrip_profile_editor_dialog_subp_codec_combo_changed (OGMRipProfileEditorDialog *dialog, GtkWidget *combo)
{
  if (dialog->priv->subp_options_button)

  if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter))
  {
    GType codec;
    GtkTreeModel *model;
    gchar *name;

    model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));
    gtk_tree_model_get (model, &iter, 1, &name, -1);

    codec = ogmrip_profile_editor_dialog_get_subp_codec_type (dialog, name);
    g_free (name);

    codec = ogmrip_combo_box_get_active_subp_codec (GTK_COMBO_BOX (combo));
    if (codec != G_TYPE_NONE)
      gtk_widget_set_sensitive (dialog->priv->subp_options_button,
          ogmrip_options_plugin_exists (codec));
  }

      GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
      NULL);
  gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
#if !GTK_CHECK_VERSION(2,22,0)
  gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
#endif
  gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
  gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
  gtk_window_set_icon_from_stock (GTK_WINDOW (dialog), GTK_STOCK_PREFERENCES);

  dialog->priv->audio_quality_label = glade_xml_get_widget (xml, "audio-quality-label");
  dialog->priv->audio_quality_spin = glade_xml_get_widget (xml, "audio-quality-spin");
  ogmrip_settings_bind (settings, dialog->priv->profile_section,
      OGMRIP_GCONF_AUDIO_QUALITY, G_OBJECT (dialog->priv->audio_quality_spin), "value");

  widget = glade_xml_get_widget (xml, "normalize-check");
  ogmrip_settings_bind (settings, dialog->priv->profile_section,

Lines 667-673 Link Here

(-)ogmrip-0.13.6.orig/src/ogmrip-profiles-dialog.c (+2 lines)
667	gtk_dialog_add_buttons (GTK_DIALOG (dialog),	667	gtk_dialog_add_buttons (GTK_DIALOG (dialog),
668	GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,	668	GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
669	NULL);	669	NULL);
		670	#if !GTK_CHECK_VERSION(2,22,0)
670	gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);	671	gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
		672	#endif
671	gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);	673	gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
672	gtk_window_set_default_size (GTK_WINDOW (dialog), 450, -1);	674	gtk_window_set_default_size (GTK_WINDOW (dialog), 450, -1);
673	gtk_window_set_title (GTK_WINDOW (dialog), _("Edit Profiles"));	675	gtk_window_set_title (GTK_WINDOW (dialog), _("Edit Profiles"));

Lines 407-414 Link Here

(-)ogmrip-0.13.6.orig/src/ogmrip-progress-dialog.c (-1 / +2 lines)
407	gtk_window_set_default_size (GTK_WINDOW (dialog), 450, -1);	407	gtk_window_set_default_size (GTK_WINDOW (dialog), 450, -1);
408	gtk_window_set_icon_from_stock (GTK_WINDOW (dialog), GTK_STOCK_EXECUTE);	408	gtk_window_set_icon_from_stock (GTK_WINDOW (dialog), GTK_STOCK_EXECUTE);
409	gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CANCEL);	409	gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CANCEL);
		410	#if !GTK_CHECK_VERSION(2,22,0)
410	gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);	411	gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
411		412	#endif
412	area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));	413	area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
413		414
414	root = glade_xml_get_widget (xml, OGMRIP_GLADE_ROOT);	415	root = glade_xml_get_widget (xml, OGMRIP_GLADE_ROOT);

Lines 611-617 Link Here

(-)ogmrip-0.13.6.orig/src/ogmrip-queue-dialog.c (+2 lines)
611		611
612	gtk_window_set_title (GTK_WINDOW (dialog), _("Encoding Queue"));	612	gtk_window_set_title (GTK_WINDOW (dialog), _("Encoding Queue"));
613	gtk_window_set_default_size (GTK_WINDOW (dialog), 500, 300);	613	gtk_window_set_default_size (GTK_WINDOW (dialog), 500, 300);
		614	#if !GTK_CHECK_VERSION(2,22,0)
614	gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);	615	gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
		616	#endif
615	gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT);	617	gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT);
616	gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT, FALSE);	618	gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT, FALSE);
617	gtk_window_set_icon_from_stock (GTK_WINDOW (dialog), GTK_STOCK_PROPERTIES);	619	gtk_window_set_icon_from_stock (GTK_WINDOW (dialog), GTK_STOCK_PROPERTIES);

Lines 130-136 Link Here

(-)ogmrip-0.13.6.orig/src/ogmrip-update-dialog.c (+2 lines)
130	GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,	130	GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
131	GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,	131	GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
132	NULL);	132	NULL);
		133	#if !GTK_CHECK_VERSION(2,22,0)
133	gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);	134	gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
		135	#endif
134	gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);	136	gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
135	gtk_window_set_default_size (GTK_WINDOW (dialog), 450, 350);	137	gtk_window_set_default_size (GTK_WINDOW (dialog), 450, 350);
136	gtk_window_set_title (GTK_WINDOW (dialog), _("Update profiles"));	138	gtk_window_set_title (GTK_WINDOW (dialog), _("Update profiles"));

Return to bug 385121

Lines 325-331 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-container.c (-3 / +3 lines)
325	*	325	*
326	* Returns: The filename, or NULL	326	* Returns: The filename, or NULL
327	*/	327	*/
328	G_CONST_RETURN gchar *	328	const gchar *
329	ogmrip_container_get_output (OGMRipContainer *container)	329	ogmrip_container_get_output (OGMRipContainer *container)
330	{	330	{
331	g_return_val_if_fail (OGMRIP_IS_CONTAINER (container), NULL);	331	g_return_val_if_fail (OGMRIP_IS_CONTAINER (container), NULL);
Lines 358-364 Link Here
358	*	358	*
359	* Returns: The label, or NULL	359	* Returns: The label, or NULL
360	*/	360	*/
361	G_CONST_RETURN gchar *	361	const gchar *
362	ogmrip_container_get_label (OGMRipContainer *container)	362	ogmrip_container_get_label (OGMRipContainer *container)
363	{	363	{
364	g_return_val_if_fail (OGMRIP_IS_CONTAINER (container), NULL);	364	g_return_val_if_fail (OGMRIP_IS_CONTAINER (container), NULL);
Lines 390-396 Link Here
390	*	390	*
391	* Returns: The FourCC, or NULL	391	* Returns: The FourCC, or NULL
392	*/	392	*/
393	G_CONST_RETURN gchar *	393	const gchar *
394	ogmrip_container_get_fourcc (OGMRipContainer *container)	394	ogmrip_container_get_fourcc (OGMRipContainer *container)
395	{	395	{
396	g_return_val_if_fail (OGMRIP_IS_CONTAINER (container), NULL);	396	g_return_val_if_fail (OGMRIP_IS_CONTAINER (container), NULL);

Lines 359-365 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-encoding.c (-8 / +8 lines)
359	return data1->nr - data2->nr;	359	return data1->nr - data2->nr;
360	}	360	}
361		361
362	static G_CONST_RETURN gchar *	362	static const gchar *
363	ogmrip_encoding_get_device (OGMRipEncoding *encoding)	363	ogmrip_encoding_get_device (OGMRipEncoding *encoding)
364	{	364	{
365	g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);	365	g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);
Lines 3558-3564 Link Here
3558	*	3558	*
3559	* Returns: The id, or NULL	3559	* Returns: The id, or NULL
3560	*/	3560	*/
3561	G_CONST_RETURN gchar *	3561	const gchar *
3562	ogmrip_encoding_get_id (OGMRipEncoding *encoding)	3562	ogmrip_encoding_get_id (OGMRipEncoding *encoding)
3563	{	3563	{
3564	g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);	3564	g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);
Lines 3590-3596 Link Here
3590	*	3590	*
3591	* Returns: The profile' section, or NULL	3591	* Returns: The profile' section, or NULL
3592	*/	3592	*/
3593	G_CONST_RETURN gchar *	3593	const gchar *
3594	ogmrip_encoding_get_profile (OGMRipEncoding *encoding)	3594	ogmrip_encoding_get_profile (OGMRipEncoding *encoding)
3595	{	3595	{
3596	g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);	3596	g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);
Lines 3630-3636 Link Here
3630	*	3630	*
3631	* Returns: The name of the encoding, or NULL	3631	* Returns: The name of the encoding, or NULL
3632	*/	3632	*/
3633	G_CONST_RETURN gchar *	3633	const gchar *
3634	ogmrip_encoding_get_label (OGMRipEncoding *encoding)	3634	ogmrip_encoding_get_label (OGMRipEncoding *encoding)
3635	{	3635	{
3636	g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);	3636	g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);
Lines 3677-3683 Link Here
3677	*	3677	*
3678	* Returns: The name of the chapter, or NULL	3678	* Returns: The name of the chapter, or NULL
3679	*/	3679	*/
3680	G_CONST_RETURN gchar *	3680	const gchar *
3681	ogmrip_encoding_get_chapter_label (OGMRipEncoding *encoding, guint nr)	3681	ogmrip_encoding_get_chapter_label (OGMRipEncoding *encoding, guint nr)
3682	{	3682	{
3683	OGMRipChapterData *data;	3683	OGMRipChapterData *data;
Lines 3837-3843 Link Here
3837	*	3837	*
3838	* Returns: The output filename, or NULL	3838	* Returns: The output filename, or NULL
3839	*/	3839	*/
3840	G_CONST_RETURN gchar *	3840	const gchar *
3841	ogmrip_encoding_get_filename (OGMRipEncoding *encoding)	3841	ogmrip_encoding_get_filename (OGMRipEncoding *encoding)
3842	{	3842	{
3843	g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);	3843	g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);
Lines 3876-3882 Link Here
3876	*	3876	*
3877	* Returns: The log filename, or NULL	3877	* Returns: The log filename, or NULL
3878	*/	3878	*/
3879	G_CONST_RETURN gchar *	3879	const gchar *
3880	ogmrip_encoding_get_logfile (OGMRipEncoding *encoding)	3880	ogmrip_encoding_get_logfile (OGMRipEncoding *encoding)
3881	{	3881	{
3882	g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);	3882	g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);
Lines 4018-4024 Link Here
4018	*	4018	*
4019	* Returns: The FourCC, or NULL	4019	* Returns: The FourCC, or NULL
4020	*/	4020	*/
4021	G_CONST_RETURN gchar *	4021	const gchar *
4022	ogmrip_encoding_get_fourcc (OGMRipEncoding *encoding)	4022	ogmrip_encoding_get_fourcc (OGMRipEncoding *encoding)
4023	{	4023	{
4024	g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);	4024	g_return_val_if_fail (OGMRIP_IS_ENCODING (encoding), NULL);

Lines 367-373 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-plugin.c (-5 / +5 lines)
367	return NULL;	367	return NULL;
368	}	368	}
369		369
370	static G_CONST_RETURN gchar *	370	static const gchar *
371	ogmrip_plugin_get_codec_name (GSList *list, GType type)	371	ogmrip_plugin_get_codec_name (GSList *list, GType type)
372	{	372	{
373	OGMRipPlugin *plugin;	373	OGMRipPlugin *plugin;
Lines 542-548 Link Here
542	*	542	*
543	* Returns: The name of the container, or NULL	543	* Returns: The name of the container, or NULL
544	*/	544	*/
545	G_CONST_RETURN gchar *	545	const gchar *
546	ogmrip_plugin_get_container_name (GType container)	546	ogmrip_plugin_get_container_name (GType container)
547	{	547	{
548	OGMRipContainerPlugin *plugin;	548	OGMRipContainerPlugin *plugin;
Lines 740-746 Link Here
740	*	740	*
741	* Returns: The name of the video codec, or NULL	741	* Returns: The name of the video codec, or NULL
742	*/	742	*/
743	G_CONST_RETURN gchar *	743	const gchar *
744	ogmrip_plugin_get_video_codec_name (GType codec)	744	ogmrip_plugin_get_video_codec_name (GType codec)
745	{	745	{
746	g_return_val_if_fail (g_type_is_a (codec, OGMRIP_TYPE_VIDEO_CODEC), NULL);	746	g_return_val_if_fail (g_type_is_a (codec, OGMRIP_TYPE_VIDEO_CODEC), NULL);
Lines 926-932 Link Here
926	*	926	*
927	* Returns: The name of the audio codec, or NULL	927	* Returns: The name of the audio codec, or NULL
928	*/	928	*/
929	G_CONST_RETURN gchar *	929	const gchar *
930	ogmrip_plugin_get_audio_codec_name (GType codec)	930	ogmrip_plugin_get_audio_codec_name (GType codec)
931	{	931	{
932	g_return_val_if_fail (g_type_is_a (codec, OGMRIP_TYPE_AUDIO_CODEC), NULL);	932	g_return_val_if_fail (g_type_is_a (codec, OGMRIP_TYPE_AUDIO_CODEC), NULL);
Lines 1070-1076 Link Here
1070	*	1070	*
1071	* Returns: The name of the subtitle codec, or NULL	1071	* Returns: The name of the subtitle codec, or NULL
1072	*/	1072	*/
1073	G_CONST_RETURN gchar *	1073	const gchar *
1074	ogmrip_plugin_get_subp_codec_name (GType codec)	1074	ogmrip_plugin_get_subp_codec_name (GType codec)
1075	{	1075	{
1076	g_return_val_if_fail (g_type_is_a (codec, OGMRIP_TYPE_SUBP_CODEC), NULL);	1076	g_return_val_if_fail (g_type_is_a (codec, OGMRIP_TYPE_SUBP_CODEC), NULL);

Lines 625-651 Link Here

(-)ogmrip-0.13.6.orig/src/ogmrip-profile-editor.c (-36 / +20 lines)
625	static void	625	static void
626	ogmrip_profile_editor_dialog_video_codec_combo_changed (OGMRipProfileEditorDialog dialog, GtkWidget combo)	626	ogmrip_profile_editor_dialog_video_codec_combo_changed (OGMRipProfileEditorDialog dialog, GtkWidget combo)
627	{	627	{
628	GtkTreeIter iter;	628	GType codec;
629		629
630	if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter))	630	codec = ogmrip_combo_box_get_active_video_codec (GTK_COMBO_BOX (combo));
		631	if (codec != G_TYPE_NONE)
631	{	632	{
632	GType codec;
633	GtkTreeModel *model;	633	GtkTreeModel *model;
		634	GtkTreeIter iter;
634	gboolean exists;	635	gboolean exists;
635	gint active;	636	gint active;
636	gchar *name;
637		637
638	model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));	638	model = gtk_combo_box_get_model (GTK_COMBO_BOX (dialog->priv->video_preset_combo));
639	gtk_tree_model_get (model, &iter, 1, &name, -1);
640		639
641	codec = ogmrip_profile_editor_dialog_get_video_codec_type (dialog, name);	640	if (gtk_tree_model_iter_nth_child (model, &iter, NULL, OGMRIP_VIDEO_PRESET_USER))
642	g_free (name);	641	gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
643
644	gtk_combo_box_remove_text (GTK_COMBO_BOX (dialog->priv->video_preset_combo), OGMRIP_VIDEO_PRESET_USER);
645		642
646	exists = ogmrip_options_plugin_exists (codec);	643	exists = ogmrip_options_plugin_exists (codec);
647	if (exists)	644	if (exists)
648	gtk_combo_box_append_text (GTK_COMBO_BOX (dialog->priv->video_preset_combo), _("User"));	645	{
		646	gtk_list_store_append (GTK_LIST_STORE (model), &iter);
		647	gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, _("User"), -1);
		648	}
649		649
650	active = gtk_combo_box_get_active (GTK_COMBO_BOX (dialog->priv->video_preset_combo));	650	active = gtk_combo_box_get_active (GTK_COMBO_BOX (dialog->priv->video_preset_combo));
651		651
Lines 660-680 Link Here
660	static void	660	static void
661	ogmrip_profile_editor_dialog_audio_codec_combo_changed (OGMRipProfileEditorDialog dialog, GtkWidget combo)	661	ogmrip_profile_editor_dialog_audio_codec_combo_changed (OGMRipProfileEditorDialog dialog, GtkWidget combo)
662	{	662	{
663	GtkTreeIter iter;	663	if (dialog->priv->audio_options_button)
664
665	if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter))
666	{	664	{
667	GType codec;	665	GType codec;
668	GtkTreeModel *model;
669	gchar *name;
670		666
671	model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));	667	codec = ogmrip_combo_box_get_active_audio_codec (GTK_COMBO_BOX (combo));
672	gtk_tree_model_get (model, &iter, 1, &name, -1);	668	if (codec != G_TYPE_NONE)
673
674	codec = ogmrip_profile_editor_dialog_get_audio_codec_type (dialog, name);
675	g_free (name);
676
677	if (dialog->priv->audio_options_button)
678	gtk_widget_set_sensitive (dialog->priv->audio_options_button,	669	gtk_widget_set_sensitive (dialog->priv->audio_options_button,
679	ogmrip_options_plugin_exists (codec));	670	ogmrip_options_plugin_exists (codec));
680	}	671	}
Lines 683-703 Link Here
683	static void	674	static void
684	ogmrip_profile_editor_dialog_subp_codec_combo_changed (OGMRipProfileEditorDialog dialog, GtkWidget combo)	675	ogmrip_profile_editor_dialog_subp_codec_combo_changed (OGMRipProfileEditorDialog dialog, GtkWidget combo)
685	{	676	{
686	GtkTreeIter iter;	677	if (dialog->priv->subp_options_button)
687
688	if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter))
689	{	678	{
690	GType codec;	679	GType codec;
691	GtkTreeModel *model;
692	gchar *name;
693
694	model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));
695	gtk_tree_model_get (model, &iter, 1, &name, -1);
696
697	codec = ogmrip_profile_editor_dialog_get_subp_codec_type (dialog, name);
698	g_free (name);
699		680
700	if (dialog->priv->subp_options_button)	681	codec = ogmrip_combo_box_get_active_subp_codec (GTK_COMBO_BOX (combo));
		682	if (codec != G_TYPE_NONE)
701	gtk_widget_set_sensitive (dialog->priv->subp_options_button,	683	gtk_widget_set_sensitive (dialog->priv->subp_options_button,
702	ogmrip_options_plugin_exists (codec));	684	ogmrip_options_plugin_exists (codec));
703	}	685	}
Lines 754-760 Link Here
754	GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,	736	GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
755	NULL);	737	NULL);
756	gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);	738	gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
		739	#if !GTK_CHECK_VERSION(2,22,0)
757	gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);	740	gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
		741	#endif
758	gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);	742	gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
759	gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);	743	gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
760	gtk_window_set_icon_from_stock (GTK_WINDOW (dialog), GTK_STOCK_PREFERENCES);	744	gtk_window_set_icon_from_stock (GTK_WINDOW (dialog), GTK_STOCK_PREFERENCES);
Lines 951-957 Link Here
951	dialog->priv->audio_quality_label = glade_xml_get_widget (xml, "audio-quality-label");	935	dialog->priv->audio_quality_label = glade_xml_get_widget (xml, "audio-quality-label");
952	dialog->priv->audio_quality_spin = glade_xml_get_widget (xml, "audio-quality-spin");	936	dialog->priv->audio_quality_spin = glade_xml_get_widget (xml, "audio-quality-spin");
953	ogmrip_settings_bind (settings, dialog->priv->profile_section,	937	ogmrip_settings_bind (settings, dialog->priv->profile_section,
954	OGMRIP_GCONF_AUDIO_QUALITY, G_OBJECT (widget), "value");	938	OGMRIP_GCONF_AUDIO_QUALITY, G_OBJECT (dialog->priv->audio_quality_spin), "value");
955		939
956	widget = glade_xml_get_widget (xml, "normalize-check");	940	widget = glade_xml_get_widget (xml, "normalize-check");
957	ogmrip_settings_bind (settings, dialog->priv->profile_section,	941	ogmrip_settings_bind (settings, dialog->priv->profile_section,

Lines 134-140 Link Here

(-)ogmrip-0.13.6.orig/libogmdvd/ogmdvd-disc.c (-4 / +4 lines)
134	return reader;	134	return reader;
135	}	135	}
136		136
137	static G_CONST_RETURN gchar *	137	static const gchar *
138	dvd_reader_get_id (dvd_reader_t *reader)	138	dvd_reader_get_id (dvd_reader_t *reader)
139	{	139	{
140	static gchar str[33];	140	static gchar str[33];
Lines 788-794 Link Here
788	*	788	*
789	* Returns: The label of the DVD, or NULL	789	* Returns: The label of the DVD, or NULL
790	*/	790	*/
791	G_CONST_RETURN gchar *	791	const gchar *
792	ogmdvd_disc_get_label (OGMDvdDisc *disc)	792	ogmdvd_disc_get_label (OGMDvdDisc *disc)
793	{	793	{
794	g_return_val_if_fail (disc != NULL, NULL);	794	g_return_val_if_fail (disc != NULL, NULL);
Lines 804-810 Link Here
804	*	804	*
805	* Returns: The identifier, or NULL	805	* Returns: The identifier, or NULL
806	*/	806	*/
807	G_CONST_RETURN gchar *	807	const gchar *
808	ogmdvd_disc_get_id (OGMDvdDisc *disc)	808	ogmdvd_disc_get_id (OGMDvdDisc *disc)
809	{	809	{
810	g_return_val_if_fail (disc != NULL, NULL);	810	g_return_val_if_fail (disc != NULL, NULL);
Lines 820-826 Link Here
820	*	820	*
821	* Returns: The device of the DVD.	821	* Returns: The device of the DVD.
822	*/	822	*/
823	G_CONST_RETURN gchar *	823	const gchar *
824	ogmdvd_disc_get_device (OGMDvdDisc *disc)	824	ogmdvd_disc_get_device (OGMDvdDisc *disc)
825	{	825	{
826	g_return_val_if_fail (disc != NULL, NULL);	826	g_return_val_if_fail (disc != NULL, NULL);

Lines 248-254 Link Here

(-)ogmrip-0.13.6.orig/libogmdvd/ogmdvd-labels.c (-10 / +10 lines)
248	*	248	*
249	* Returns: A constant string, or NULL	249	* Returns: A constant string, or NULL
250	*/	250	*/
251	G_CONST_RETURN gchar *	251	const gchar *
252	ogmdvd_get_video_format_label (gint format)	252	ogmdvd_get_video_format_label (gint format)
253	{	253	{
254	static const gchar *video_format[] =	254	static const gchar *video_format[] =
Lines 272-278 Link Here
272	*	272	*
273	* Returns: A constant string, or NULL	273	* Returns: A constant string, or NULL
274	*/	274	*/
275	G_CONST_RETURN gchar *	275	const gchar *
276	ogmdvd_get_display_aspect_label (gint aspect)	276	ogmdvd_get_display_aspect_label (gint aspect)
277	{	277	{
278	static gchar *display_aspect[] =	278	static gchar *display_aspect[] =
Lines 296-302 Link Here
296	*	296	*
297	* Returns: A constant string, or NULL	297	* Returns: A constant string, or NULL
298	*/	298	*/
299	G_CONST_RETURN gchar *	299	const gchar *
300	ogmdvd_get_audio_format_label (gint format)	300	ogmdvd_get_audio_format_label (gint format)
301	{	301	{
302	static gchar *audio_format[] =	302	static gchar *audio_format[] =
Lines 324-330 Link Here
324	*	324	*
325	* Returns: A constant string, or NULL	325	* Returns: A constant string, or NULL
326	*/	326	*/
327	G_CONST_RETURN gchar *	327	const gchar *
328	ogmdvd_get_audio_channels_label (gint channels)	328	ogmdvd_get_audio_channels_label (gint channels)
329	{	329	{
330	static gchar *audio_channels[] =	330	static gchar *audio_channels[] =
Lines 352-358 Link Here
352	*	352	*
353	* Returns: A constant string, or NULL	353	* Returns: A constant string, or NULL
354	*/	354	*/
355	G_CONST_RETURN gchar *	355	const gchar *
356	ogmdvd_get_audio_quantization_label (gint quantization)	356	ogmdvd_get_audio_quantization_label (gint quantization)
357	{	357	{
358	static gchar *audio_quantization[] =	358	static gchar *audio_quantization[] =
Lines 376-382 Link Here
376	*	376	*
377	* Returns: A constant string, or NULL	377	* Returns: A constant string, or NULL
378	*/	378	*/
379	G_CONST_RETURN gchar *	379	const gchar *
380	ogmdvd_get_audio_content_label (gint content)	380	ogmdvd_get_audio_content_label (gint content)
381	{	381	{
382	static gchar *audio_content[] =	382	static gchar *audio_content[] =
Lines 401-407 Link Here
401	*	401	*
402	* Returns: A constant string, or NULL	402	* Returns: A constant string, or NULL
403	*/	403	*/
404	G_CONST_RETURN gchar *	404	const gchar *
405	ogmdvd_get_subp_content_label (gint content)	405	ogmdvd_get_subp_content_label (gint content)
406	{	406	{
407	static gchar *subp_content[] =	407	static gchar *subp_content[] =
Lines 437-443 Link Here
437	*	437	*
438	* Returns: A constant string, or NULL	438	* Returns: A constant string, or NULL
439	*/	439	*/
440	G_CONST_RETURN gchar *	440	const gchar *
441	ogmdvd_get_language_label (gint code)	441	ogmdvd_get_language_label (gint code)
442	{	442	{
443	const gchar *lang;	443	const gchar *lang;
Lines 460-466 Link Here
460	*	460	*
461	* Returns: A constant string, or NULL	461	* Returns: A constant string, or NULL
462	*/	462	*/
463	G_CONST_RETURN gchar *	463	const gchar *
464	ogmdvd_get_language_iso639_1 (gint code)	464	ogmdvd_get_language_iso639_1 (gint code)
465	{	465	{
466	static gchar lang[3];	466	static gchar lang[3];
Lines 489-495 Link Here
489	*	489	*
490	* Returns: A constant string, or NULL	490	* Returns: A constant string, or NULL
491	*/	491	*/
492	G_CONST_RETURN gchar *	492	const gchar *
493	ogmdvd_get_language_iso639_2 (gint code)	493	ogmdvd_get_language_iso639_2 (gint code)
494	{	494	{
495	const gchar *lang;	495	const gchar *lang;

Lines 23-38 Link Here

(-)ogmrip-0.13.6.orig/libogmdvd/ogmdvd-labels.h (-10 / +10 lines)
23		23
24	G_BEGIN_DECLS	24	G_BEGIN_DECLS
25		25
26	G_CONST_RETURN gchar * ogmdvd_get_video_format_label (gint format);	26	const gchar * ogmdvd_get_video_format_label (gint format);
27	G_CONST_RETURN gchar * ogmdvd_get_display_aspect_label (gint aspect);	27	const gchar * ogmdvd_get_display_aspect_label (gint aspect);
28	G_CONST_RETURN gchar * ogmdvd_get_audio_format_label (gint format);	28	const gchar * ogmdvd_get_audio_format_label (gint format);
29	G_CONST_RETURN gchar * ogmdvd_get_audio_channels_label (gint channels);	29	const gchar * ogmdvd_get_audio_channels_label (gint channels);
30	G_CONST_RETURN gchar * ogmdvd_get_audio_quantization_label (gint quantization);	30	const gchar * ogmdvd_get_audio_quantization_label (gint quantization);
31	G_CONST_RETURN gchar * ogmdvd_get_audio_content_label (gint content);	31	const gchar * ogmdvd_get_audio_content_label (gint content);
32	G_CONST_RETURN gchar * ogmdvd_get_subp_content_label (gint content);	32	const gchar * ogmdvd_get_subp_content_label (gint content);
33	G_CONST_RETURN gchar * ogmdvd_get_language_label (gint code);	33	const gchar * ogmdvd_get_language_label (gint code);
34	G_CONST_RETURN gchar * ogmdvd_get_language_iso639_1 (gint code);	34	const gchar * ogmdvd_get_language_iso639_1 (gint code);
35	G_CONST_RETURN gchar * ogmdvd_get_language_iso639_2 (gint code);	35	const gchar * ogmdvd_get_language_iso639_2 (gint code);
36		36
37	G_END_DECLS	37	G_END_DECLS
38		38

Lines 91-106 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-container.h (-3 / +3 lines)
91	void ogmrip_container_set_options (OGMRipContainer *container,	91	void ogmrip_container_set_options (OGMRipContainer *container,
92	const gchar *section);	92	const gchar *section);
93		93
94	G_CONST_RETURN	94	const
95	gchar * ogmrip_container_get_output (OGMRipContainer *container);	95	gchar * ogmrip_container_get_output (OGMRipContainer *container);
96	void ogmrip_container_set_output (OGMRipContainer *container,	96	void ogmrip_container_set_output (OGMRipContainer *container,
97	const gchar *output);	97	const gchar *output);
98	G_CONST_RETURN	98	const
99	gchar * ogmrip_container_get_label (OGMRipContainer *container);	99	gchar * ogmrip_container_get_label (OGMRipContainer *container);
100	void ogmrip_container_set_label (OGMRipContainer *container,	100	void ogmrip_container_set_label (OGMRipContainer *container,
101	const gchar *label);	101	const gchar *label);
102		102
103	G_CONST_RETURN	103	const
104	gchar * ogmrip_container_get_fourcc (OGMRipContainer *container);	104	gchar * ogmrip_container_get_fourcc (OGMRipContainer *container);
105	void ogmrip_container_set_fourcc (OGMRipContainer *container,	105	void ogmrip_container_set_fourcc (OGMRipContainer *container,
106	const gchar *fourcc);	106	const gchar *fourcc);

Lines 362-377 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-encoding.h (-7 / +7 lines)
362		362
363	guint32 ogmrip_encoding_get_flags (OGMRipEncoding *encoding);	363	guint32 ogmrip_encoding_get_flags (OGMRipEncoding *encoding);
364		364
365	G_CONST_RETURN	365	const
366	gchar * ogmrip_encoding_get_id (OGMRipEncoding *encoding);	366	gchar * ogmrip_encoding_get_id (OGMRipEncoding *encoding);
367	OGMDvdTitle * ogmrip_encoding_get_title (OGMRipEncoding *encoding);	367	OGMDvdTitle * ogmrip_encoding_get_title (OGMRipEncoding *encoding);
368		368
369	G_CONST_RETURN	369	const
370	gchar * ogmrip_encoding_get_profile (OGMRipEncoding *encoding);	370	gchar * ogmrip_encoding_get_profile (OGMRipEncoding *encoding);
371	void ogmrip_encoding_set_profile (OGMRipEncoding *encoding,	371	void ogmrip_encoding_set_profile (OGMRipEncoding *encoding,
372	const gchar *profile);	372	const gchar *profile);
373		373
374	G_CONST_RETURN	374	const
375	gchar * ogmrip_encoding_get_label (OGMRipEncoding *encoding);	375	gchar * ogmrip_encoding_get_label (OGMRipEncoding *encoding);
376	void ogmrip_encoding_set_label (OGMRipEncoding *encoding,	376	void ogmrip_encoding_set_label (OGMRipEncoding *encoding,
377	const gchar *label);	377	const gchar *label);
Lines 386-392 Link Here
386	gint ogmrip_encoding_get_chapters_language (OGMRipEncoding *encoding);	386	gint ogmrip_encoding_get_chapters_language (OGMRipEncoding *encoding);
387	void ogmrip_encoding_set_chapters_language (OGMRipEncoding *encoding,	387	void ogmrip_encoding_set_chapters_language (OGMRipEncoding *encoding,
388	guint language);	388	guint language);
389	G_CONST_RETURN	389	const
390	gchar * ogmrip_encoding_get_chapter_label (OGMRipEncoding *encoding,	390	gchar * ogmrip_encoding_get_chapter_label (OGMRipEncoding *encoding,
391	guint nr);	391	guint nr);
392	void ogmrip_encoding_set_chapter_label (OGMRipEncoding *encoding,	392	void ogmrip_encoding_set_chapter_label (OGMRipEncoding *encoding,
Lines 404-414 Link Here
404	gboolean ogmrip_encoding_get_keep_tmp_files (OGMRipEncoding *encoding);	404	gboolean ogmrip_encoding_get_keep_tmp_files (OGMRipEncoding *encoding);
405	void ogmrip_encoding_set_keep_tmp_files (OGMRipEncoding *encoding,	405	void ogmrip_encoding_set_keep_tmp_files (OGMRipEncoding *encoding,
406	gboolean keep_tmp_files);	406	gboolean keep_tmp_files);
407	G_CONST_RETURN	407	const
408	gchar * ogmrip_encoding_get_filename (OGMRipEncoding *encoding);	408	gchar * ogmrip_encoding_get_filename (OGMRipEncoding *encoding);
409	void ogmrip_encoding_set_filename (OGMRipEncoding *encoding,	409	void ogmrip_encoding_set_filename (OGMRipEncoding *encoding,
410	const gchar *filename);	410	const gchar *filename);
411	G_CONST_RETURN	411	const
412	gchar * ogmrip_encoding_get_logfile (OGMRipEncoding *encoding);	412	gchar * ogmrip_encoding_get_logfile (OGMRipEncoding *encoding);
413		413
414	gint ogmrip_encoding_get_threads (OGMRipEncoding *encoding);	414	gint ogmrip_encoding_get_threads (OGMRipEncoding *encoding);
Lines 423-429 Link Here
423	gboolean ogmrip_encoding_set_container_type (OGMRipEncoding *encoding,	423	gboolean ogmrip_encoding_set_container_type (OGMRipEncoding *encoding,
424	GType type,	424	GType type,
425	GError **error);	425	GError **error);
426	G_CONST_RETURN	426	const
427	gchar * ogmrip_encoding_get_fourcc (OGMRipEncoding *encoding);	427	gchar * ogmrip_encoding_get_fourcc (OGMRipEncoding *encoding);
428	void ogmrip_encoding_set_fourcc (OGMRipEncoding *encoding,	428	void ogmrip_encoding_set_fourcc (OGMRipEncoding *encoding,
429	const gchar *fourcc);	429	const gchar *fourcc);

Lines 196-202 Link Here

(-)ogmrip-0.13.6.orig/libogmrip/ogmrip-plugin.h (-4 / +4 lines)
196	GType ogmrip_plugin_get_nth_container (guint n);	196	GType ogmrip_plugin_get_nth_container (guint n);
197	GType ogmrip_plugin_get_container_by_name (const gchar *name);	197	GType ogmrip_plugin_get_container_by_name (const gchar *name);
198	gint ogmrip_plugin_get_container_index (GType container);	198	gint ogmrip_plugin_get_container_index (GType container);
199	G_CONST_RETURN	199	const
200	gchar * ogmrip_plugin_get_container_name (GType container);	200	gchar * ogmrip_plugin_get_container_name (GType container);
201	gboolean ogmrip_plugin_get_container_bframes (GType container);	201	gboolean ogmrip_plugin_get_container_bframes (GType container);
202	gint ogmrip_plugin_get_container_max_audio (GType container);	202	gint ogmrip_plugin_get_container_max_audio (GType container);
Lines 216-222 Link Here
216	GType ogmrip_plugin_get_nth_video_codec (guint n);	216	GType ogmrip_plugin_get_nth_video_codec (guint n);
217	GType ogmrip_plugin_get_video_codec_by_name (const gchar *name);	217	GType ogmrip_plugin_get_video_codec_by_name (const gchar *name);
218	gint ogmrip_plugin_get_video_codec_index (GType codec);	218	gint ogmrip_plugin_get_video_codec_index (GType codec);
219	G_CONST_RETURN	219	const
220	gchar * ogmrip_plugin_get_video_codec_name (GType codec);	220	gchar * ogmrip_plugin_get_video_codec_name (GType codec);
221	gint ogmrip_plugin_get_video_codec_format (GType codec);	221	gint ogmrip_plugin_get_video_codec_format (GType codec);
222	gint ogmrip_plugin_get_video_codec_passes (GType codec);	222	gint ogmrip_plugin_get_video_codec_passes (GType codec);
Lines 236-242 Link Here
236	GType ogmrip_plugin_get_nth_audio_codec (guint n);	236	GType ogmrip_plugin_get_nth_audio_codec (guint n);
237	GType ogmrip_plugin_get_audio_codec_by_name (const gchar *name);	237	GType ogmrip_plugin_get_audio_codec_by_name (const gchar *name);
238	gint ogmrip_plugin_get_audio_codec_index (GType codec);	238	gint ogmrip_plugin_get_audio_codec_index (GType codec);
239	G_CONST_RETURN	239	const
240	gchar * ogmrip_plugin_get_audio_codec_name (GType codec);	240	gchar * ogmrip_plugin_get_audio_codec_name (GType codec);
241	gint ogmrip_plugin_get_audio_codec_format (GType codec);	241	gint ogmrip_plugin_get_audio_codec_format (GType codec);
242	GModule * ogmrip_plugin_get_audio_codec_module (GType codec);	242	GModule * ogmrip_plugin_get_audio_codec_module (GType codec);
Lines 254-260 Link Here
254	GType ogmrip_plugin_get_nth_subp_codec (guint n);	254	GType ogmrip_plugin_get_nth_subp_codec (guint n);
255	GType ogmrip_plugin_get_subp_codec_by_name (const gchar *name);	255	GType ogmrip_plugin_get_subp_codec_by_name (const gchar *name);
256	gint ogmrip_plugin_get_subp_codec_index (GType codec);	256	gint ogmrip_plugin_get_subp_codec_index (GType codec);
257	G_CONST_RETURN	257	const
258	gchar * ogmrip_plugin_get_subp_codec_name (GType codec);	258	gchar * ogmrip_plugin_get_subp_codec_name (GType codec);
259	gint ogmrip_plugin_get_subp_codec_format (GType codec);	259	gint ogmrip_plugin_get_subp_codec_format (GType codec);
260	gboolean ogmrip_plugin_get_subp_codec_text (GType codec);	260	gboolean ogmrip_plugin_get_subp_codec_text (GType codec);

Lines 218-234 Link Here

(-)ogmrip-0.13.6.orig/src/ogmrip-crop-dialog.c (-11 / +15 lines)
218	}	218	}
219		219
220	static void	220	static void
221	ogmrip_crop_dialog_scale_value_changed (OGMRipCropDialog dialog, GtkWidget scale)	221	ogmrip_crop_dialog_scale_button_released (OGMRipCropDialog dialog, GdkEventButton event, GtkWidget *scale)
222	{	222	{
223	gulong frame;	223	if (!event \|\| event->button == 1)
224	gchar *text;	224	{
		225	gulong frame;
		226	gchar *text;
225		227
226	frame = (guint) gtk_range_get_value (GTK_RANGE (scale));	228	frame = (guint) gtk_range_get_value (GTK_RANGE (scale));
227	text = g_strdup_printf (_("Frame %lu of %lu"), frame, dialog->priv->length);	229	text = g_strdup_printf (_("Frame %lu of %lu"), frame, dialog->priv->length);
228	gtk_label_set_text (GTK_LABEL (dialog->priv->label), text);	230	gtk_label_set_text (GTK_LABEL (dialog->priv->label), text);
229	g_free (text);	231	g_free (text);
230		232
231	ogmrip_crop_dialog_grab_frame (dialog, frame);	233	ogmrip_crop_dialog_grab_frame (dialog, frame);
		234	}
232	}	235	}
233		236
234	G_DEFINE_TYPE (OGMRipCropDialog, ogmrip_crop_dialog, GTK_TYPE_DIALOG)	237	G_DEFINE_TYPE (OGMRipCropDialog, ogmrip_crop_dialog, GTK_TYPE_DIALOG)
Lines 291-299 Link Here
291	dialog->priv->label = glade_xml_get_widget (xml, "frame-label");	294	dialog->priv->label = glade_xml_get_widget (xml, "frame-label");
292		295
293	dialog->priv->scale = glade_xml_get_widget (xml, "frame-scale");	296	dialog->priv->scale = glade_xml_get_widget (xml, "frame-scale");
294	gtk_range_set_update_policy (GTK_RANGE (dialog->priv->scale), GTK_UPDATE_DELAYED);	297	g_signal_connect_swapped (dialog->priv->scale, "button-release-event",
295	g_signal_connect_swapped (dialog->priv->scale, "value-changed",	298	G_CALLBACK (ogmrip_crop_dialog_scale_button_released), dialog);
296	G_CALLBACK (ogmrip_crop_dialog_scale_value_changed), dialog);
297		299
298	g_object_unref (xml);	300	g_object_unref (xml);
299	}	301	}
Lines 352-357 Link Here
352	frame = g_random_int_range (1, dialog->priv->length);	354	frame = g_random_int_range (1, dialog->priv->length);
353	gtk_range_set_value (GTK_RANGE (dialog->priv->scale), frame);	355	gtk_range_set_value (GTK_RANGE (dialog->priv->scale), frame);
354		356
		357	ogmrip_crop_dialog_scale_button_released (dialog, NULL, dialog->priv->scale);
		358
355	return GTK_WIDGET (dialog);	359	return GTK_WIDGET (dialog);
356	}	360	}
357		361