2
* nvidia-settings: A tool for configuring the NVIDIA X driver on Unix
5
* Copyright (C) 2004 NVIDIA Corporation.
7
* This program is free software; you can redistribute it and/or
8
* modify it under the terms of Version 2 of the GNU General Public
9
* License as published by the Free Software Foundation.
11
* This program is distributed in the hope that it will be useful, but
12
* WITHOUT ANY WARRANTY; without even the implied warranty of
13
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See Version 2
14
* of the GNU General Public License for more details.
16
* You should have received a copy of the GNU General Public License
17
* along with this program; if not, write to the:
19
* Free Software Foundation, Inc.
20
* 59 Temple Place - Suite 330
21
* Boston, MA 02111-1307, USA
26
#include <NvCtrlAttributes.h>
28
#include "dfp_banner.h"
30
#include "ctkdisplaydevice-dfp.h"
32
#include "ctkimagesliders.h"
33
#include "ctkconfig.h"
37
static GtkWidget *make_scaling_radio_button(CtkDisplayDeviceDfp
38
*ctk_display_device_dfp,
40
GtkWidget *prev_radio,
44
static GtkWidget *make_dithering_radio_button(CtkDisplayDeviceDfp
45
*ctk_display_device_dfp,
47
GtkWidget *prev_radio,
51
static void dfp_scaling_changed(GtkWidget *widget, gpointer user_data);
53
static void dfp_dithering_changed(GtkWidget *widget, gpointer user_data);
55
static void reset_button_clicked(GtkButton *button, gpointer user_data);
58
dfp_scaling_update_radio_buttons(CtkDisplayDeviceDfp *ctk_display_device_dfp,
63
dfp_dithering_update_radio_buttons(CtkDisplayDeviceDfp *ctk_display_device_dfp,
66
static void dfp_update_received(GtkObject *object, gpointer arg1,
70
#define FRAME_PADDING 5
72
#define __SCALING (1<<0)
73
#define __DITHERING (1<<1)
76
static const char *__scaling_help =
77
"A FlatPanel usually has a single 'native' "
78
"resolution. If you are using a resolution that is "
79
"smaller than the FlatPanel's native resolution, then "
80
"FlatPanel Scaling can adjust how the image is "
81
"displayed on the FlatPanel.";
83
static const char *__dithering_help =
84
"Some GeForce2 GPUs required dithering to "
85
"properly display on a flatpanel; this option allows "
86
"you to control the dithering behavior.";
89
GType ctk_display_device_dfp_get_type(void)
91
static GType ctk_display_device_dfp_type = 0;
93
if (!ctk_display_device_dfp_type) {
94
static const GTypeInfo ctk_display_device_dfp_info = {
95
sizeof (CtkDisplayDeviceDfpClass),
97
NULL, /* base_finalize */
98
NULL, /* class_init, */
99
NULL, /* class_finalize */
100
NULL, /* class_data */
101
sizeof (CtkDisplayDeviceDfp),
103
NULL, /* instance_init */
106
ctk_display_device_dfp_type = g_type_register_static (GTK_TYPE_VBOX,
107
"CtkDisplayDeviceDfp", &ctk_display_device_dfp_info, 0);
110
return ctk_display_device_dfp_type;
116
* ctk_display_device_dfp_new() - constructor for the DFP display
120
GtkWidget* ctk_display_device_dfp_new(NvCtrlAttributeHandle *handle,
121
CtkConfig *ctk_config,
123
unsigned int display_device_mask,
127
CtkDisplayDeviceDfp *ctk_display_device_dfp;
130
GtkWidget *hbox, *vbox;
138
GtkWidget *alignment;
142
guint8 *image_buffer = NULL;
143
const nv_image_t *img;
146
object = g_object_new(CTK_TYPE_DISPLAY_DEVICE_DFP, NULL);
148
ctk_display_device_dfp = CTK_DISPLAY_DEVICE_DFP(object);
149
ctk_display_device_dfp->handle = handle;
150
ctk_display_device_dfp->ctk_config = ctk_config;
151
ctk_display_device_dfp->display_device_mask = display_device_mask;
152
ctk_display_device_dfp->name = name;
154
gtk_box_set_spacing(GTK_BOX(object), 10);
158
hbox = gtk_hbox_new(FALSE, 0);
159
gtk_box_pack_start(GTK_BOX(object), hbox, FALSE, FALSE, 0);
161
frame = gtk_frame_new(NULL);
162
gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, FALSE, 0);
164
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
166
img = &dfp_banner_image;
168
image_buffer = decompress_image_data(img);
170
image = gtk_image_new_from_pixbuf
171
(gdk_pixbuf_new_from_data(image_buffer, GDK_COLORSPACE_RGB,
172
FALSE, 8, img->width, img->height,
173
img->width * img->bytes_per_pixel,
174
free_decompressed_image, NULL));
176
gtk_container_add(GTK_CONTAINER(frame), image);
179
* create the reset button (which we need while creating the
180
* controls in this page so that we can set the button's
181
* sensitivity), though we pack it at the bottom of the page
184
label = gtk_label_new("Reset Hardware Defaults");
185
hbox = gtk_hbox_new(FALSE, 0);
186
ctk_display_device_dfp->reset_button = gtk_button_new();
188
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 15);
189
gtk_container_add(GTK_CONTAINER(ctk_display_device_dfp->reset_button),
192
alignment = gtk_alignment_new(1, 1, 0, 0);
193
gtk_container_add(GTK_CONTAINER(alignment),
194
ctk_display_device_dfp->reset_button);
195
gtk_box_pack_end(GTK_BOX(object), alignment, TRUE, TRUE, 0);
197
g_signal_connect(G_OBJECT(ctk_display_device_dfp->reset_button),
198
"clicked", G_CALLBACK(reset_button_clicked),
199
(gpointer) ctk_display_device_dfp);
201
ctk_config_set_tooltip(ctk_config, ctk_display_device_dfp->reset_button,
202
"The Reset Hardware Defaults button restores "
203
"the DFP settings to their default values.");
205
/* create the hbox to store scaling and dithering */
207
hbox = gtk_hbox_new(FALSE, FRAME_PADDING);
208
gtk_box_pack_start(GTK_BOX(object), hbox, TRUE, TRUE, FRAME_PADDING);
210
/* FlatPanel Scaling */
212
ret = NvCtrlGetDisplayAttribute(handle, display_device_mask,
213
NV_CTRL_FLATPANEL_SCALING, &val);
215
if (ret == NvCtrlSuccess) {
216
frame = gtk_frame_new("FlatPanel Scaling");
217
eventbox = gtk_event_box_new();
218
gtk_container_add(GTK_CONTAINER(eventbox), frame);
219
gtk_box_pack_start(GTK_BOX(hbox), eventbox, TRUE, TRUE, 0);
221
ctk_config_set_tooltip(ctk_config, eventbox, __scaling_help);
223
vbox = gtk_vbox_new(FALSE, FRAME_PADDING);
224
gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING);
225
gtk_container_add(GTK_CONTAINER(frame), vbox);
228
radio0 = make_scaling_radio_button
229
(ctk_display_device_dfp, vbox, NULL, "Default",
230
NV_CTRL_FLATPANEL_SCALING_DEFAULT);
232
radio1 = make_scaling_radio_button
233
(ctk_display_device_dfp, vbox, radio0, "Scaled",
234
NV_CTRL_FLATPANEL_SCALING_SCALED);
236
radio2 = make_scaling_radio_button
237
(ctk_display_device_dfp, vbox, radio1, "Centered",
238
NV_CTRL_FLATPANEL_SCALING_CENTERED);
240
radio3 = make_scaling_radio_button
241
(ctk_display_device_dfp, vbox, radio2, "Fixed Aspect Ratio Scaled",
242
NV_CTRL_FLATPANEL_SCALING_ASPECT_SCALED);
245
* XXX TODO: determine when we should advertise Monitor
246
* Scaling (aka "Native" scaling)
249
ctk_display_device_dfp->scaling_buttons
250
[NV_CTRL_FLATPANEL_SCALING_NATIVE] = NULL;
253
dfp_scaling_update_radio_buttons(ctk_display_device_dfp, val);
255
g_signal_connect(G_OBJECT(ctk_event),
256
CTK_EVENT_NAME(NV_CTRL_FLATPANEL_SCALING),
257
G_CALLBACK(dfp_update_received),
258
(gpointer) ctk_display_device_dfp);
260
ctk_display_device_dfp->active_attributes |= __SCALING;
264
for (i = 0; i < NV_CTRL_FLATPANEL_SCALING_ASPECT_SCALED+1; i++) {
265
ctk_display_device_dfp->scaling_buttons[i] = NULL;
268
ctk_display_device_dfp->active_attributes &= ~__SCALING;
271
/* FlatPanel Dithering */
273
ret = NvCtrlGetDisplayAttribute(handle, display_device_mask,
274
NV_CTRL_FLATPANEL_DITHERING, &val);
276
if (ret == NvCtrlSuccess) {
277
frame = gtk_frame_new("FlatPanel Dithering");
278
eventbox = gtk_event_box_new();
279
gtk_container_add(GTK_CONTAINER(eventbox), frame);
280
gtk_box_pack_start(GTK_BOX(hbox), eventbox, TRUE, TRUE, 0);
282
ctk_config_set_tooltip(ctk_config, eventbox, __dithering_help);
284
vbox = gtk_vbox_new(FALSE, FRAME_PADDING);
285
gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING);
286
gtk_container_add(GTK_CONTAINER(frame), vbox);
289
radio0 = make_dithering_radio_button
290
(ctk_display_device_dfp, vbox, NULL, "Default",
291
NV_CTRL_FLATPANEL_DITHERING_DEFAULT);
293
radio1 = make_dithering_radio_button
294
(ctk_display_device_dfp, vbox, radio0, "Enabled",
295
NV_CTRL_FLATPANEL_DITHERING_ENABLED);
297
radio2 = make_dithering_radio_button
298
(ctk_display_device_dfp, vbox, radio1, "Disabled",
299
NV_CTRL_FLATPANEL_DITHERING_DISABLED);
301
dfp_dithering_update_radio_buttons(ctk_display_device_dfp, val);
303
g_signal_connect(G_OBJECT(ctk_event),
304
CTK_EVENT_NAME(NV_CTRL_FLATPANEL_DITHERING),
305
G_CALLBACK(dfp_update_received),
306
(gpointer) ctk_display_device_dfp);
308
ctk_display_device_dfp->active_attributes |= __DITHERING;
312
for (i = 0; i < NV_CTRL_FLATPANEL_DITHERING_DISABLED+1; i++) {
313
ctk_display_device_dfp->dithering_buttons[i] = NULL;
316
ctk_display_device_dfp->active_attributes &= ~__DITHERING;
319
/* pack the image sliders */
321
ctk_display_device_dfp->image_sliders =
322
ctk_image_sliders_new(handle, ctk_config, ctk_event,
323
ctk_display_device_dfp->reset_button,
324
display_device_mask, name);
325
if (ctk_display_device_dfp->image_sliders) {
326
gtk_box_pack_start(GTK_BOX(object),
327
ctk_display_device_dfp->image_sliders,
333
gtk_widget_show_all(GTK_WIDGET(object));
335
return GTK_WIDGET(object);
337
} /* ctk_display_device_dfp_new() */
342
* make_scaling_radio_button() - create a radio button and plug it
343
* into the scaling radio group.
346
static GtkWidget *make_scaling_radio_button(CtkDisplayDeviceDfp
347
*ctk_display_device_dfp,
349
GtkWidget *prev_radio,
356
radio = gtk_radio_button_new_with_label_from_widget
357
(GTK_RADIO_BUTTON(prev_radio), label);
359
radio = gtk_radio_button_new_with_label(NULL, label);
362
gtk_box_pack_start(GTK_BOX(vbox), radio, FALSE, FALSE, 0);
364
g_object_set_data(G_OBJECT(radio), "scaling_value",
365
GINT_TO_POINTER(value));
367
g_signal_connect(G_OBJECT(radio), "toggled",
368
G_CALLBACK(dfp_scaling_changed),
369
(gpointer) ctk_display_device_dfp);
371
ctk_display_device_dfp->scaling_buttons[value] = radio;
375
} /* make_scaling_radio_button() */
380
* make_dithering_radio_button() - create a radio button and plug it
381
* into the dithering radio group.
384
static GtkWidget *make_dithering_radio_button(CtkDisplayDeviceDfp
385
*ctk_display_device_dfp,
387
GtkWidget *prev_radio,
394
radio = gtk_radio_button_new_with_label_from_widget
395
(GTK_RADIO_BUTTON(prev_radio), label);
397
radio = gtk_radio_button_new_with_label(NULL, label);
400
gtk_box_pack_start(GTK_BOX(vbox), radio, FALSE, FALSE, 0);
402
g_object_set_data(G_OBJECT(radio), "dithering_value",
403
GINT_TO_POINTER(value));
405
g_signal_connect(G_OBJECT(radio), "toggled",
406
G_CALLBACK(dfp_dithering_changed),
407
(gpointer) ctk_display_device_dfp);
409
ctk_display_device_dfp->dithering_buttons[value] = radio;
413
} /* make_dithering_radio_button() */
418
* post_dfp_scaling_update() - helper function for
419
* dfp_scaling_changed() and dfp_update_received(); this does whatever
420
* work is necessary after scaling has been updated -- currently, this
421
* just means posting a statusbar message.
425
post_dfp_scaling_update(CtkDisplayDeviceDfp *ctk_display_device_dfp,
428
static const char *scaling_string_table[] = {
429
"Default", /* NV_CTRL_FLATPANEL_SCALING_DEFAULT */
430
"Monitor Scaled", /* NV_CTRL_FLATPANEL_SCALING_NATIVE */
431
"Scaled", /* NV_CTRL_FLATPANEL_SCALING_SCALED */
432
"Centered", /* NV_CTRL_FLATPANEL_SCALING_CENTERED */
433
"Aspect Scaled" /* NV_CTRL_FLATPANEL_SCALING_ASPECT_SCALED */
436
if (value > NV_CTRL_FLATPANEL_SCALING_ASPECT_SCALED) return;
438
ctk_config_statusbar_message(ctk_display_device_dfp->ctk_config,
439
"Set FlatPanel Scaling for %s to %s.",
440
ctk_display_device_dfp->name,
441
scaling_string_table[value]);
443
} /* post_dfp_scaling_update() */
448
* dfp_scaling_changed() - callback function for changes to the
449
* scaling radio button group; if the specified radio button is
450
* active, send updated state to the server
453
static void dfp_scaling_changed(GtkWidget *widget, gpointer user_data)
455
CtkDisplayDeviceDfp *ctk_display_device_dfp =
456
CTK_DISPLAY_DEVICE_DFP(user_data);
460
enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
464
user_data = g_object_get_data(G_OBJECT(widget), "scaling_value");
465
value = GPOINTER_TO_INT(user_data);
467
NvCtrlSetDisplayAttribute(ctk_display_device_dfp->handle,
468
ctk_display_device_dfp->display_device_mask,
469
NV_CTRL_FLATPANEL_SCALING, value);
471
post_dfp_scaling_update(ctk_display_device_dfp, value);
474
} /* dfp_scaling_changed() */
479
* post_dfp_dithering_update() - helper function for
480
* dfp_dithering_changed() and dfp_update_received(); this does
481
* whatever work is necessary after dithering has been updated --
482
* currently, this just means posting a statusbar message.
486
post_dfp_dithering_update(CtkDisplayDeviceDfp *ctk_display_device_dfp,
489
static const char *dithering_string_table[] = {
490
"Default", /* NV_CTRL_FLATPANEL_DITHERING_DEFAULT */
491
"Enabled", /* NV_CTRL_FLATPANEL_DITHERING_ENABLED */
492
"Disabled" /* NV_CTRL_FLATPANEL_DITHERING_DISABLED */
495
if (value > NV_CTRL_FLATPANEL_DITHERING_DISABLED) return;
497
ctk_config_statusbar_message(ctk_display_device_dfp->ctk_config,
498
"Set FlatPanel Dithering for %s to %s.",
499
ctk_display_device_dfp->name,
500
dithering_string_table[value]);
502
} /* post_dfp_dithering_update() */
507
* dfp_dithering_changed() - callback function for changes to the
508
* dithering radio button group; if the specified radio button is
509
* active, send updated state to the server
512
static void dfp_dithering_changed(GtkWidget *widget, gpointer user_data)
514
CtkDisplayDeviceDfp *ctk_display_device_dfp =
515
CTK_DISPLAY_DEVICE_DFP(user_data);
520
enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
524
user_data = g_object_get_data(G_OBJECT(widget), "dithering_value");
525
value = GPOINTER_TO_INT(user_data);
527
NvCtrlSetDisplayAttribute(ctk_display_device_dfp->handle,
528
ctk_display_device_dfp->display_device_mask,
529
NV_CTRL_FLATPANEL_DITHERING, value);
531
post_dfp_dithering_update(ctk_display_device_dfp, value);
534
} /* dfp_dithering_changed() */
539
* reset_button_clicked() - callback when the reset button is clicked
542
static void reset_button_clicked(GtkButton *button, gpointer user_data)
544
CtkDisplayDeviceDfp *ctk_display_device_dfp =
545
CTK_DISPLAY_DEVICE_DFP(user_data);
549
if (ctk_display_device_dfp->image_sliders) {
550
ctk_image_sliders_reset
551
(CTK_IMAGE_SLIDERS(ctk_display_device_dfp->image_sliders));
555
* if scaling is active, send the default scaling value to the
556
* server and update the radio button group
559
if (ctk_display_device_dfp->active_attributes & __SCALING) {
561
value = NV_CTRL_FLATPANEL_SCALING_DEFAULT;
563
NvCtrlSetDisplayAttribute(ctk_display_device_dfp->handle,
564
ctk_display_device_dfp->display_device_mask,
565
NV_CTRL_FLATPANEL_SCALING, value);
567
dfp_scaling_update_radio_buttons(ctk_display_device_dfp, value);
571
* if dithering is active, send the default dithering value to the
572
* server and update the radio button group
575
if (ctk_display_device_dfp->active_attributes & __DITHERING) {
577
value = NV_CTRL_FLATPANEL_DITHERING_DEFAULT;
579
NvCtrlSetDisplayAttribute(ctk_display_device_dfp->handle,
580
ctk_display_device_dfp->display_device_mask,
581
NV_CTRL_FLATPANEL_DITHERING, value);
583
dfp_dithering_update_radio_buttons(ctk_display_device_dfp, value);
586
/* status bar message */
588
ctk_config_statusbar_message(ctk_display_device_dfp->ctk_config,
589
"Reset hardware defaults for %s.",
590
ctk_display_device_dfp->name);
592
} /* reset_button_clicked() */
597
* dfp_scaling_update_radio_buttons() - update the scaling radio
598
* button group, making the specified scaling value active.
602
dfp_scaling_update_radio_buttons(CtkDisplayDeviceDfp *ctk_display_device_dfp,
605
GtkWidget *b, *button = NULL;
608
if ((value < NV_CTRL_FLATPANEL_SCALING_DEFAULT) ||
609
(value > NV_CTRL_FLATPANEL_SCALING_ASPECT_SCALED)) return;
611
button = ctk_display_device_dfp->scaling_buttons[value];
615
/* turn off signal handling for all the scaling buttons */
617
for (i = 0; i < 5; i++) {
618
b = ctk_display_device_dfp->scaling_buttons[i];
621
g_signal_handlers_block_by_func
622
(G_OBJECT(b), G_CALLBACK(dfp_scaling_changed),
623
(gpointer) ctk_display_device_dfp);
626
/* set the appropriate button active */
628
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
630
/* turn on signal handling for all the scaling buttons */
632
for (i = 0; i < 5; i++) {
633
b = ctk_display_device_dfp->scaling_buttons[i];
636
g_signal_handlers_unblock_by_func
637
(G_OBJECT(b), G_CALLBACK(dfp_scaling_changed),
638
(gpointer) ctk_display_device_dfp);
641
} /* dfp_scaling_update_radio_buttons() */
646
* dfp_dithering_update_radio_buttons() - update the dithering radio
647
* button group, making the specified dithering value active.
651
dfp_dithering_update_radio_buttons(CtkDisplayDeviceDfp *ctk_display_device_dfp,
654
GtkWidget *b, *button = NULL;
657
if ((value < NV_CTRL_FLATPANEL_DITHERING_DEFAULT) ||
658
(value > NV_CTRL_FLATPANEL_DITHERING_DISABLED)) return;
660
button = ctk_display_device_dfp->dithering_buttons[value];
664
/* turn off signal handling for all the dithering buttons */
666
for (i = 0; i < 3; i++) {
667
b = ctk_display_device_dfp->dithering_buttons[i];
670
g_signal_handlers_block_by_func
671
(G_OBJECT(b), G_CALLBACK(dfp_dithering_changed),
672
(gpointer) ctk_display_device_dfp);
675
/* set the appropriate button active */
677
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
679
/* turn on signal handling for all the dithering buttons */
681
for (i = 0; i < 3; i++) {
682
b = ctk_display_device_dfp->dithering_buttons[i];
685
g_signal_handlers_unblock_by_func
686
(G_OBJECT(b), G_CALLBACK(dfp_dithering_changed),
687
(gpointer) ctk_display_device_dfp);
689
} /* dfp_dithering_update_radio_buttons() */
694
* dfp_dithering_update_received() - callback function for changed DFP
695
* settings; this is called when we receive an event indicating that
696
* another NV-CONTROL client changed any of the settings that we care
700
static void dfp_update_received(GtkObject *object, gpointer arg1,
703
CtkEventStruct *event_struct = (CtkEventStruct *) arg1;
704
CtkDisplayDeviceDfp *ctk_display_device_dfp =
705
CTK_DISPLAY_DEVICE_DFP(user_data);
707
/* if the event is not for this display device, return */
709
if (!(event_struct->display_mask &
710
ctk_display_device_dfp->display_device_mask)) {
714
switch (event_struct->attribute) {
715
case NV_CTRL_FLATPANEL_SCALING:
716
dfp_scaling_update_radio_buttons(ctk_display_device_dfp,
717
event_struct->value);
718
post_dfp_scaling_update(ctk_display_device_dfp, event_struct->value);
721
case NV_CTRL_FLATPANEL_DITHERING:
722
dfp_dithering_update_radio_buttons(ctk_display_device_dfp,
723
event_struct->value);
724
post_dfp_dithering_update(ctk_display_device_dfp, event_struct->value);
730
} /* dfp_dithering_update_received() */
735
* ctk_display_device_dfp_create_help() - construct the DFP display
739
GtkTextBuffer *ctk_display_device_dfp_create_help(GtkTextTagTable *table,
741
*ctk_display_device_dfp)
745
gboolean ret = FALSE;
747
b = gtk_text_buffer_new(table);
749
gtk_text_buffer_get_iter_at_offset(b, &i, 0);
751
ctk_help_title(b, &i, "%s Help", ctk_display_device_dfp->name);
753
if (ctk_display_device_dfp->active_attributes & __SCALING) {
754
ctk_help_heading(b, &i, "FlatPanel Scaling");
755
ctk_help_para(b, &i, __scaling_help);
757
ctk_help_term(b, &i, "Default");
758
ctk_help_para(b, &i, "The driver will choose what scaling state is "
761
ctk_help_term(b, &i, "Scaled");
762
ctk_help_para(b, &i, "The image will be expanded to fit the entire "
765
ctk_help_term(b, &i, "Centered");
766
ctk_help_para(b, &i, "The image will only occupy the number of pixels "
767
"needed and be centered on the FlatPanel.");
769
ctk_help_term(b, &i, "Fixed Aspect Ratio Scaled");
770
ctk_help_para(b, &i, "The image will be expanded (like when Scaled), "
771
"but the image will retain the original aspect ratio.");
775
if (ctk_display_device_dfp->active_attributes & __DITHERING) {
776
ctk_help_heading(b, &i, "FlatPanel Dithering");
777
ctk_help_para(b, &i, __dithering_help);
779
ctk_help_term(b, &i, "Default");
780
ctk_help_para(b, &i, "The driver will choose when to dither.");
782
ctk_help_term(b, &i, "Enabled");
783
ctk_help_para(b, &i, "Force dithering on.");
785
ctk_help_term(b, &i, "Disabled");
786
ctk_help_para(b, &i, "Force dithering off.");
791
if (ctk_display_device_dfp->image_sliders) {
792
ret |= add_image_sharpening_help
793
(CTK_IMAGE_SLIDERS(ctk_display_device_dfp->image_sliders), b, &i);
797
ctk_help_para(b, &i, "There are no configurable options available "
798
"for %s.", ctk_display_device_dfp->name);
805
} /* ctk_display_device_dfp_create_help() */
added
removed
src/gtk+-2.x/ctkdisplaydevice-dfp.c
