static gdouble
get_screen_dpi (SoliPrintPreview *preview)
{
GdkScreen *screen;
gdouble dpi;
static gboolean warning_shown = FALSE;
screen = gtk_widget_get_screen (GTK_WIDGET (preview));
if (screen == NULL)
{
return PRINTER_DPI;
}
dpi = gdk_screen_get_resolution (screen);
if (dpi < 30.0 || 600.0 < dpi)
{
if (!warning_shown)
{
g_warning ("Invalid the x-resolution for the screen, assuming 96dpi");
warning_shown = TRUE;
}
dpi = 96.0;
}
return dpi;
}
/* Taken from the Gtk+ file gtkfilechooserdefault.c
* Copyright (C) 2003, Red Hat, Inc.
*
* Changed by File-Roller authors
*
* Guesses a size based upon font sizes */
static int
get_font_size (GtkWidget *widget)
{
GtkStyleContext *context;
GtkStateFlags state;
int font_size;
GdkScreen *screen;
double resolution;
PangoFontDescription *font;
context = gtk_widget_get_style_context (widget);
state = gtk_widget_get_state_flags (widget);
screen = gtk_widget_get_screen (widget);
if (screen) {
resolution = gdk_screen_get_resolution (screen);
if (resolution < 0.0) /* will be -1 if the resolution is not defined in the GdkScreen */
resolution = 96.0;
}
else
resolution = 96.0; /* wheeee */
gtk_style_context_get (context, state, "font", &font, NULL);
font_size = pango_font_description_get_size (font);
font_size = PANGO_PIXELS (font_size) * resolution / 72.0;
return font_size;
}
static gboolean
webkit_get_font_size (GValue *value,
GVariant *variant,
gpointer user_data)
{
PangoFontDescription *font = pango_font_description_from_string (
g_variant_get_string (variant, NULL));
int size;
if (font == NULL)
return FALSE;
size = pango_font_description_get_size (font) / PANGO_SCALE;
if (pango_font_description_get_size_is_absolute (font))
{
GdkScreen *screen = gdk_screen_get_default ();
double dpi;
if (screen != NULL)
dpi = gdk_screen_get_resolution (screen);
else
dpi = BORING_DPI_DEFAULT;
size = (gint) (size / (dpi / 72));
}
g_value_set_int (value, size);
pango_font_description_free (font);
return TRUE;
}
float
draw_get_font_size (drawctx_t *ctx) {
draw_init_font (ctx, NULL);
GdkScreen *screen = gdk_screen_get_default ();
float dpi = gdk_screen_get_resolution (screen);
PangoFontDescription *desc = ctx->font_style->font_desc;
return (float)(pango_font_description_get_size (desc) / PANGO_SCALE * dpi / 72);
}
static GtkCssValue *
gtk_css_value_initial_compute (GtkCssValue *value,
guint property_id,
GtkStyleProviderPrivate *provider,
GtkCssStyle *style,
GtkCssStyle *parent_style)
{
GtkSettings *settings;
switch (property_id)
{
case GTK_CSS_PROPERTY_DPI:
settings = _gtk_style_provider_private_get_settings (provider);
if (settings)
{
GdkScreen *screen = _gtk_settings_get_screen (settings);
double resolution = gdk_screen_get_resolution (screen);
if (resolution > 0.0)
return _gtk_css_number_value_new (resolution, GTK_CSS_NUMBER);
}
break;
case GTK_CSS_PROPERTY_FONT_FAMILY:
settings = _gtk_style_provider_private_get_settings (provider);
if (settings)
{
PangoFontDescription *description;
char *font_name;
GtkCssValue *value;
g_object_get (settings, "gtk-font-name", &font_name, NULL);
description = pango_font_description_from_string (font_name);
g_free (font_name);
if (description == NULL)
break;
if (pango_font_description_get_set_fields (description) & PANGO_FONT_MASK_FAMILY)
{
value = _gtk_css_array_value_new (_gtk_css_string_value_new (pango_font_description_get_family (description)));
pango_font_description_free (description);
return value;
}
pango_font_description_free (description);
}
break;
default:
break;
}
return _gtk_css_value_compute (_gtk_css_style_property_get_initial_value (_gtk_css_style_property_lookup_by_id (property_id)),
property_id,
provider,
style,
parent_style);
}
gdouble GetCurrentResolution(void){
#if GTK_CHECK_VERSION(2,10,0)
GdkScreen *screen = gdk_screen_get_default();
return(gdk_screen_get_resolution(screen));
#else
return(96.0);
#endif
}
void *
xv_doc_get_paint (struct xv_doc_t *doc, unsigned int n,
double scale,
PgdRenderMode mode,
double * width, double *height)
{
struct xv_page_t *page;
if (n >= doc->n_pages) {
return NULL;
}
if (!doc->pages[n]) {
doc->pages[n] = g_malloc0(sizeof(struct xv_page_t));
doc->pages[n]->page = poppler_document_get_page(doc->doc, n);
if (!doc->pages[n]->page) {
printf("Could not open page %d of document\n", n);
return NULL;
}
poppler_page_get_size(doc->pages[n]->page,
&doc->pages[n]->width,
&doc->pages[n]->height);
}
page = doc->pages[n];
/* auto scale */
if (scale == 0) {
double a, b;
a = *width / page->width;
b = *height / page->height;
scale = a < b? a : b;
}
/* A4 paper size */
if (scale == -1) {
GdkScreen * def = gdk_screen_get_default();
gdouble res;
g_assert (def != NULL);
res = gdk_screen_get_resolution (def);
scale = 8.3 * res / page->width;
}
/* rendering */
if (mode == PGD_RENDER_CAIRO) {
xv_doc_get_surface (page, mode, scale);
} else {
xv_doc_get_gdkbuf (page, mode, scale);
}
*width = doc->pages[n]->width * scale;
*height = doc->pages[n]->height * scale;
return page->pixbuf;
}
/* subfunction of gtk_plot_cairo_draw_string(). */
static gint
drawstring(GtkPlotPC *pc,
gint angle,
gint dx, gint dy,
GtkPSFont *psfont, gint height,
const gchar *text)
{
cairo_t *cairo = GTK_PLOT_CAIRO(pc)->cairo;
PangoLayout *layout = GTK_PLOT_CAIRO(pc)->layout;
PangoFontDescription *font;
PangoRectangle rect;
PangoFontMap *map;
gint ret_value;
gint dpi_cairo, dpi_screen;
GdkScreen *screen = gdk_screen_get_default();
if(!text || strlen(text) == 0) return 0;
cairo_save(cairo);
map = pango_cairo_font_map_get_default();
dpi_cairo = pango_cairo_font_map_get_resolution(PANGO_CAIRO_FONT_MAP(map));
dpi_screen = gdk_screen_get_resolution(screen);
height *= (double)dpi_screen/(double)dpi_cairo;
font = gtk_psfont_get_font_description(psfont, height);
pango_layout_set_font_description(GTK_PLOT_CAIRO(pc)->layout, font);
pango_layout_set_text(GTK_PLOT_CAIRO(pc)->layout, text, strlen(text));
pango_layout_get_extents(GTK_PLOT_CAIRO(pc)->layout, NULL, &rect);
if (psfont->i18n_latinfamily && psfont->vertical) {
/* vertical-writing CJK postscript fonts. */
return rect.height;
}
else
{
/* horizontal writing */
if(angle == 90)
// cairo_translate(cairo, dx, dy-PANGO_PIXELS(rect.width));
cairo_translate(cairo, dx, dy);
else if(angle == 270)
cairo_translate(cairo, dx+PANGO_PIXELS(rect.height), dy);
else if(angle == 180)
cairo_translate(cairo, dx-PANGO_PIXELS(rect.width), dy);
else
cairo_translate(cairo, dx, dy);
}
cairo_rotate(cairo, -angle * G_PI / 180);
pango_cairo_update_layout(cairo, layout);
pango_cairo_show_layout(cairo, layout);
cairo_restore(cairo);
pango_font_description_free(font);
ret_value = (angle == 0 || angle == 180) ? rect.width : rect.height;
return PANGO_PIXELS(rect.width);
}
double RenderThemeGtk::getScreenDPI()
{
// FIXME: Really this should be the widget's screen.
GdkScreen* screen = gdk_screen_get_default();
if (!screen)
return 96; // Default to 96 DPI.
float dpi = gdk_screen_get_resolution(screen);
if (dpi <= 0)
return 96;
return dpi;
}
int ZLGtkPaintContext::stringHeight() const {
if (myFontDescription == 0) {
return 0;
}
if (myStringHeight == -1) {
#if GTK_CHECK_VERSION(2,10,0)
if (pango_font_description_get_size_is_absolute(myFontDescription)) {
myStringHeight = pango_font_description_get_size(myFontDescription) / PANGO_SCALE + 2;
} else {
static const int resolution = gdk_screen_get_resolution(gdk_screen_get_default());
myStringHeight = pango_font_description_get_size(myFontDescription) * resolution / 72 / PANGO_SCALE + 2;
}
#else // GTK_CHECK_VERSION(2,10,0)
myStringHeight = pango_font_description_get_size(myFontDescription) / PANGO_SCALE + 2;
#endif // GTK_CHECK_VERSION(2,10,0)
}
return myStringHeight;
}
static int sg_font_width(PangoFontDescription *font)
{
/* returns size in pixels */
int wid = 0;
double dpi = 96.0; /* see below */
PangoContext *ctx;
PangoFontMetrics *m;
#if HAVE_GTK_LINK_BUTTON_NEW
dpi = gdk_screen_get_resolution(gdk_display_get_default_screen(gdk_display_get_default())); /* pixels/inch */
#endif
ctx = gdk_pango_context_get();
m = pango_context_get_metrics(ctx, font, gtk_get_default_language()); /* returns size in pango-scaled points (1024/72 inch) */
wid = (int)((dpi / 72.0) * PANGO_PIXELS(pango_font_metrics_get_approximate_char_width(m)));
pango_font_metrics_unref(m);
g_object_unref(ctx);
return(wid);
}
static void
style_updated (GtkWidget *widget,
void *user_data)
{
GdkDisplay *gdkdisplay;
GdkScreen *gdkscreen;
WnckScreen *screen;
PangoContext *context = (PangoContext *) user_data;
gdkdisplay = gdk_display_get_default ();
gdkscreen = gdk_display_get_default_screen (gdkdisplay);
screen = wnck_screen_get_default ();
update_style (widget);
pango_cairo_context_set_resolution (context, gdk_screen_get_resolution (gdkscreen));
decorations_changed (screen);
}
static void
gdk_screen_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GdkScreen *screen = GDK_SCREEN (object);
switch (prop_id)
{
case PROP_FONT_OPTIONS:
g_value_set_pointer (value, (gpointer) gdk_screen_get_font_options (screen));
break;
case PROP_RESOLUTION:
g_value_set_double (value, gdk_screen_get_resolution (screen));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/**
* gdk_pango_context_get_for_screen:
* @screen: the #GdkScreen for which the context is to be created.
*
* Creates a #PangoContext for @screen.
*
* The context must be freed when you're finished with it.
*
* When using GTK+, normally you should use gtk_widget_get_pango_context()
* instead of this function, to get the appropriate context for
* the widget you intend to render text onto.
*
* The newly created context will have the default font options
* (see #cairo_font_options_t) for the screen; if these options
* change it will not be updated. Using gtk_widget_get_pango_context()
* is more convenient if you want to keep a context around and track
* changes to the screen's font rendering settings.
*
* Return value: (transfer full): a new #PangoContext for @screen
*
* Since: 2.2
**/
PangoContext *
gdk_pango_context_get_for_screen (GdkScreen *screen)
{
PangoFontMap *fontmap;
PangoContext *context;
const cairo_font_options_t *options;
double dpi;
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
fontmap = pango_cairo_font_map_get_default ();
context = pango_font_map_create_context (fontmap);
options = gdk_screen_get_font_options (screen);
pango_cairo_context_set_font_options (context, options);
dpi = gdk_screen_get_resolution (screen);
pango_cairo_context_set_resolution (context, dpi);
return context;
}
static int sg_font_height(PangoFontDescription *font)
{
/* returns size in pixels */
double dpi = 96.0; /* a plausible guess */
int hgt = 0;
PangoContext *ctx;
PangoFontMetrics *m;
#if HAVE_GTK_LINK_BUTTON_NEW
/* gtk 2.1: gdk_display_get_default, gdk_display_get_default_screen */
/* gtk 2.9: gdk_screen_get_resolution */
dpi = gdk_screen_get_resolution(gdk_display_get_default_screen(gdk_display_get_default()));
#endif
ctx = gdk_pango_context_get();
m = pango_context_get_metrics(ctx, font, gtk_get_default_language());
hgt = (int)((dpi / 72.0) * PANGO_PIXELS(pango_font_metrics_get_ascent(m)));
pango_font_metrics_unref(m);
g_object_unref(ctx);
return(hgt);
}
static gboolean ddb_equalizer_real_expose_event (GtkWidget* base, GdkEventExpose* event) {
DdbEqualizer * self;
gboolean result = FALSE;
GdkColor _tmp0_ = {0};
GdkColor fore_bright_color;
GdkColor c1;
GdkColor _tmp1_ = {0};
GdkColor c2;
GdkColor fore_dark_color;
gint width;
gint height;
GdkDrawable* d;
GdkGCValues _tmp2_ = {0};
GdkGCValues _tmp3_;
GdkGC* gc;
double step;
gint i = 0;
double vstep;
PangoLayout* l;
PangoContext* ctx;
PangoFontDescription* fd;
gint fontsize;
gboolean _tmp7_ = FALSE;
char* tmp;
double val;
const char* _tmp9_;
char* _tmp10_;
const char* _tmp11_;
char* _tmp12_;
GdkRectangle _tmp13_ = {0};
GdkRectangle _tmp14_;
gint count;
GdkRectangle _tmp16_ = {0};
GdkRectangle _tmp17_;
gint bar_w;
GdkRectangle _tmp22_ = {0};
GdkRectangle _tmp23_;
self = (DdbEqualizer*) base;
fore_bright_color = (gtkui_get_bar_foreground_color (&_tmp0_), _tmp0_);
c1 = fore_bright_color;
c2 = (gtkui_get_bar_background_color (&_tmp1_), _tmp1_);
fore_dark_color = c2;
fore_dark_color.red = fore_dark_color.red + ((guint16) ((gint16) ((c1.red - c2.red) * 0.5)));
fore_dark_color.green = fore_dark_color.green + ((guint16) ((gint16) ((c1.green - c2.green) * 0.5)));
fore_dark_color.blue = fore_dark_color.blue + ((guint16) ((gint16) ((c1.blue - c2.blue) * 0.5)));
width = ((GtkWidget*) self)->allocation.width;
height = ((GtkWidget*) self)->allocation.height;
d = _g_object_ref0 ((GdkDrawable*) gtk_widget_get_window ((GtkWidget*) self));
gc = _g_object_ref0 (GDK_DRAWABLE_GET_CLASS (d)->create_gc (d, (_tmp3_ = (memset (&_tmp2_, 0, sizeof (GdkGCValues)), _tmp2_), &_tmp3_), 0));
gdk_gc_set_rgb_fg_color (gc, &c2);
gdk_draw_rectangle (d, gc, TRUE, 0, 0, width, height);
gdk_gc_set_rgb_fg_color (gc, &fore_dark_color);
step = ((double) (width - self->priv->margin_left)) / ((double) (DDB_EQUALIZER_bands + 1));
{
gboolean _tmp4_;
i = 0;
_tmp4_ = TRUE;
while (TRUE) {
if (!_tmp4_) {
i++;
}
_tmp4_ = FALSE;
if (!(i < DDB_EQUALIZER_bands)) {
break;
}
gdk_draw_line (d, gc, ((gint) ((i + 1) * step)) + self->priv->margin_left, 0, ((gint) ((i + 1) * step)) + self->priv->margin_left, height - self->priv->margin_bottom);
}
}
vstep = (double) (height - self->priv->margin_bottom);
{
double di;
di = (double) 0;
{
gboolean _tmp5_;
_tmp5_ = TRUE;
while (TRUE) {
if (!_tmp5_) {
di = di + 0.25;
}
_tmp5_ = FALSE;
if (!(di < 2)) {
break;
}
gdk_draw_line (d, gc, self->priv->margin_left, (gint) ((di - self->priv->preamp) * vstep), width, (gint) ((di - self->priv->preamp) * vstep));
}
}
}
gdk_gc_set_rgb_fg_color (gc, &fore_bright_color);
l = gtk_widget_create_pango_layout ((GtkWidget*) self, NULL);
ctx = _g_object_ref0 (pango_layout_get_context (l));
fd = pango_font_description_copy (gtk_widget_get_style ((GtkWidget*) self)->font_desc);
pango_font_description_set_size (fd, (gint) (pango_font_description_get_size (gtk_widget_get_style ((GtkWidget*) self)->font_desc) * 0.7));
pango_context_set_font_description (ctx, fd);
{
gboolean _tmp6_;
i = 0;
_tmp6_ = TRUE;
while (TRUE) {
PangoRectangle ink = {0};
PangoRectangle log = {0};
gint offs;
if (!_tmp6_) {
i++;
}
_tmp6_ = FALSE;
if (!(i < DDB_EQUALIZER_bands)) {
break;
}
pango_layout_set_text (l, freqs[i], (gint) g_utf8_strlen (freqs[i], -1));
pango_layout_get_pixel_extents (l, &ink, &log);
offs = 2;
if ((i % 2) != 0) {
offs = offs + 2;
}
gdk_draw_layout (d, gc, (((gint) ((i + 1) * step)) + self->priv->margin_left) - (ink.width / 2), (height - self->priv->margin_bottom) + offs, l);
}
}
pango_font_description_set_size (fd, (gint) pango_font_description_get_size (gtk_widget_get_style ((GtkWidget*) self)->font_desc));
pango_context_set_font_description (ctx, fd);
pango_layout_set_width (l, self->priv->margin_left - 1);
pango_layout_set_alignment (l, PANGO_ALIGN_RIGHT);
fontsize = (gint) ((pango_units_to_double (pango_font_description_get_size (fd)) * gdk_screen_get_resolution (gdk_screen_get_default ())) / 72);
if (self->priv->mouse_y >= 0) {
_tmp7_ = self->priv->mouse_y < (height - self->priv->margin_bottom);
} else {
_tmp7_ = FALSE;
}
if (_tmp7_) {
double db;
const char* _tmp8_;
char* tmp;
db = ddb_equalizer_scale (self, ((double) (self->priv->mouse_y - 1)) / ((double) ((height - self->priv->margin_bottom) - 2)));
_tmp8_ = NULL;
if (db > 0) {
_tmp8_ = "+";
} else {
_tmp8_ = "";
}
tmp = g_strdup_printf ("%s%.1fdB", _tmp8_, db);
pango_layout_set_text (l, tmp, (gint) g_utf8_strlen (tmp, -1));
gdk_draw_layout (d, gc, self->priv->margin_left - 1, self->priv->mouse_y - 3, l);
_g_free0 (tmp);
}
tmp = NULL;
val = ddb_equalizer_scale (self, (double) 1);
_tmp9_ = NULL;
if (val > 0) {
_tmp9_ = "+";
} else {
_tmp9_ = "";
}
tmp = (_tmp10_ = g_strdup_printf ("%s%.1fdB", _tmp9_, val), _g_free0 (tmp), _tmp10_);
pango_layout_set_text (l, tmp, (gint) g_utf8_strlen (tmp, -1));
gdk_draw_layout (d, gc, self->priv->margin_left - 1, (height - self->priv->margin_bottom) - fontsize, l);
val = ddb_equalizer_scale (self, (double) 0);
_tmp11_ = NULL;
if (val > 0) {
_tmp11_ = "+";
} else {
_tmp11_ = "";
}
tmp = (_tmp12_ = g_strdup_printf ("%s%.1fdB", _tmp11_, val), _g_free0 (tmp), _tmp12_);
pango_layout_set_text (l, tmp, (gint) g_utf8_strlen (tmp, -1));
gdk_draw_layout (d, gc, self->priv->margin_left - 1, 1, l);
pango_layout_set_text (l, "+0dB", 4);
gdk_draw_layout (d, gc, self->priv->margin_left - 1, ((gint) ((1 - self->priv->preamp) * (height - self->priv->margin_bottom))) - (fontsize / 2), l);
pango_layout_set_text (l, "preamp", 6);
pango_layout_set_alignment (l, PANGO_ALIGN_LEFT);
gdk_draw_layout (d, gc, 1, (height - self->priv->margin_bottom) + 2, l);
gdk_draw_rectangle (d, gc, FALSE, self->priv->margin_left, 0, (width - self->priv->margin_left) - 1, (height - self->priv->margin_bottom) - 1);
gdk_gc_set_line_attributes (gc, 2, GDK_LINE_SOLID, GDK_CAP_NOT_LAST, GDK_JOIN_MITER);
gdk_gc_set_clip_rectangle (gc, (_tmp14_ = (_tmp13_.x = 0, _tmp13_.y = (gint) (self->priv->preamp * (height - self->priv->margin_bottom)), _tmp13_.width = 11, _tmp13_.height = height, _tmp13_), &_tmp14_));
gdk_gc_set_rgb_fg_color (gc, &fore_bright_color);
count = ((gint) ((height - self->priv->margin_bottom) / 6)) + 1;
{
gint j;
j = 0;
{
gboolean _tmp15_;
_tmp15_ = TRUE;
while (TRUE) {
if (!_tmp15_) {
j++;
}
_tmp15_ = FALSE;
if (!(j < count)) {
break;
}
gdk_draw_rectangle (d, gc, TRUE, 1, ((height - self->priv->margin_bottom) - (j * 6)) - 6, 11, 4);
}
}
}
gdk_gc_set_clip_rectangle (gc, (_tmp17_ = (_tmp16_.x = self->priv->margin_left + 1, _tmp16_.y = 1, _tmp16_.width = (width - self->priv->margin_left) - 2, _tmp16_.height = (height - self->priv->margin_bottom) - 2, _tmp16_), &_tmp17_));
gdk_gc_set_rgb_fg_color (gc, &fore_bright_color);
bar_w = 11;
if (step < bar_w) {
bar_w = ((gint) step) - 1;
}
{
gboolean _tmp18_;
i = 0;
_tmp18_ = TRUE;
while (TRUE) {
GdkRectangle _tmp19_ = {0};
GdkRectangle _tmp20_;
if (!_tmp18_) {
i++;
}
_tmp18_ = FALSE;
if (!(i < DDB_EQUALIZER_bands)) {
break;
}
gdk_gc_set_clip_rectangle (gc, (_tmp20_ = (_tmp19_.x = (((gint) ((i + 1) * step)) + self->priv->margin_left) - (bar_w / 2), _tmp19_.y = (gint) (self->priv->values[i] * (height - self->priv->margin_bottom)), _tmp19_.width = 11, _tmp19_.height = height, _tmp19_), &_tmp20_));
count = ((gint) (((height - self->priv->margin_bottom) * (1 - self->priv->values[i])) / 6)) + 1;
{
gint j;
j = 0;
{
gboolean _tmp21_;
_tmp21_ = TRUE;
while (TRUE) {
if (!_tmp21_) {
j++;
}
_tmp21_ = FALSE;
if (!(j < count)) {
break;
}
gdk_draw_rectangle (d, gc, TRUE, (((gint) ((i + 1) * step)) + self->priv->margin_left) - (bar_w / 2), ((height - self->priv->margin_bottom) - (j * 6)) - 6, bar_w, 4);
}
}
}
}
}
gdk_gc_set_clip_rectangle (gc, (_tmp23_ = (_tmp22_.x = 0, _tmp22_.y = 0, _tmp22_.width = width, _tmp22_.height = height, _tmp22_), &_tmp23_));
gdk_gc_set_line_attributes (gc, 1, GDK_LINE_ON_OFF_DASH, GDK_CAP_NOT_LAST, GDK_JOIN_MITER);
gdk_draw_line (d, gc, self->priv->margin_left + 1, self->priv->mouse_y, width, self->priv->mouse_y);
result = FALSE;
_g_free0 (tmp);
_pango_font_description_free0 (fd);
_g_object_unref0 (ctx);
_g_object_unref0 (l);
_g_object_unref0 (gc);
_g_object_unref0 (d);
return result;
}
int
main (int argc,
char** argv)
{
GtkWidget* window;
GdkRGBA transparent = {0.0, 0.0, 0.0, 0.0};
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
if (!window)
return 0;
gtk_window_set_type_hint (GTK_WINDOW (window),
GDK_WINDOW_TYPE_HINT_DOCK);
gtk_widget_add_events (window,
GDK_POINTER_MOTION_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK);
// hook up input/event handlers to window
g_signal_connect (G_OBJECT (window),
"screen-changed",
G_CALLBACK (screen_changed_handler),
NULL);
g_signal_connect (G_OBJECT (window),
"composited-changed",
G_CALLBACK (composited_changed_handler),
NULL);
gtk_window_move (GTK_WINDOW (window), POS_X, POS_Y);
// make sure the window opens with a RGBA-visual
screen_changed_handler (window, NULL, NULL);
gtk_widget_realize (window);
gdk_window_set_background_rgba (gtk_widget_get_window (window),
&transparent);
// hook up window-event handlers to window
g_signal_connect (G_OBJECT (window),
"draw",
G_CALLBACK (expose_handler),
NULL);
// FIXME: read out current mouse-pointer position every 1/25 second
g_timeout_add (1000/40,
(GSourceFunc) pointer_update,
(gpointer) window);
g_timeout_add (10000,
(GSourceFunc) quit,
NULL);
// "clear" input-mask, set title/icon/attributes
gtk_widget_set_app_paintable (window, TRUE);
gtk_window_set_decorated (GTK_WINDOW (window), FALSE);
gtk_window_set_keep_above (GTK_WINDOW (window), TRUE);
gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
gtk_window_set_accept_focus (GTK_WINDOW (window), FALSE);
gtk_window_set_opacity (GTK_WINDOW (window), 1.0f);
gtk_widget_set_size_request (window,
(gint) (BUBBLE_WIDTH + 2.0f *
BUBBLE_SHADOW_SIZE),
(gint) (BUBBLE_HEIGHT + 2.0f *
BUBBLE_SHADOW_SIZE));
gtk_widget_show (window);
g_composited = gdk_screen_is_composited(gtk_widget_get_screen (window));
update_input_shape (window, 1, 1);
update_shape (window,
(gint) CORNER_RADIUS,
(gint) BUBBLE_SHADOW_SIZE);
set_bg_blur (window, TRUE);
setup_tile ((gint) (BUBBLE_WIDTH + 2.0f * BUBBLE_SHADOW_SIZE),
(gint) (BUBBLE_HEIGHT + 2.0f * BUBBLE_SHADOW_SIZE));
g_text = setup_text_tile (gdk_screen_get_font_options (
gtk_widget_get_screen (window)),
gdk_screen_get_resolution (
gtk_widget_get_screen (window)),
(gint) (BUBBLE_WIDTH - 2*BUBBLE_SHADOW_SIZE),
(gint) (3.0f * BUBBLE_HEIGHT));
g_print ("This test will run for 10 seconds and then quit.\n");
gtk_main ();
tile_destroy (g_tile);
tile_destroy (g_text);
return 0;
}
/*----------------------------------------------------------------------------
* add a node to an Agraph. Check also if the node is yet in the hash_table so
* that we can build the label of the node with the class-data.
*/
static ClsNode*
cls_inherit_create_node (AnjutaClassInheritance *plugin,
const IAnjutaSymbol *node_sym)
{
ClsNode *cls_node;
Agsym_t *sym;
gint font_size;
const gchar *font_name;
#define FONT_SIZE_STR_LEN 16
gchar font_size_str[FONT_SIZE_STR_LEN];
cls_node = g_new0 (ClsNode, 1);
cls_node->graph = plugin->graph;
cls_node->canvas = plugin->canvas;
cls_node->plugin = plugin;
cls_node->sym_manager =
anjuta_shell_get_interface (ANJUTA_PLUGIN (plugin)->shell,
IAnjutaSymbolManager, NULL);
cls_node->sym_name =
g_strdup (ianjuta_symbol_get_string (IANJUTA_SYMBOL (node_sym),
IANJUTA_SYMBOL_FIELD_NAME,
NULL));
cls_node->klass_id =
ianjuta_symbol_get_int (IANJUTA_SYMBOL (node_sym),
IANJUTA_SYMBOL_FIELD_ID,
NULL);
cls_node->members =
g_hash_table_new_full (g_str_hash, g_str_equal,
(GDestroyNotify) g_free,
(GDestroyNotify) cls_node_item_free);
cls_node->expansion_status = CLS_NODE_COLLAPSED;
cls_node->drawn_expansion_status = CLS_NODE_COLLAPSED;
cls_node->edges_to =
g_hash_table_new_full (g_direct_hash, g_direct_equal,
NULL, (GDestroyNotify)cls_node_edge_free);
cls_node->edges_from = g_hash_table_new (g_direct_hash, g_direct_equal);
/* let's add the node to the graph */
if ((cls_node->agnode = agnode (cls_node->graph,
cls_node->sym_name)) == NULL)
{
cls_node_free (cls_node);
return NULL;
}
/* set the font */
if (!(sym = agfindattr(plugin->graph->proto->n, "fontname")))
sym = agnodeattr(plugin->graph, "fontname", "");
font_name =
pango_font_description_get_family (plugin->canvas->style->font_desc);
agxset(cls_node->agnode, sym->index, (char*)font_name);
/* set the font-size */
if (!(sym = agfindattr(plugin->graph->proto->n, "fontsize")))
sym = agnodeattr(plugin->graph, "fontsize", "");
font_size =
pango_font_description_get_size (plugin->canvas->style->font_desc)/
PANGO_SCALE;
/* The above font size in points is with real screen DPI, but graphviz
* rendering is done at fixed INCH_TO_PIXELS_CONVERSION_FACTOR dpi. So
* convert to the right font size points for graphviz.
*/
font_size =
font_size * gdk_screen_get_resolution (gdk_screen_get_default ())
/ INCH_TO_PIXELS_CONVERSION_FACTOR;
snprintf (font_size_str, FONT_SIZE_STR_LEN, "%d", font_size);
agxset(cls_node->agnode, sym->index, font_size_str);
if (!(sym = agfindattr(plugin->graph->proto->n, "ratio")))
sym = agnodeattr(plugin->graph, "ratio", "");
agxset(cls_node->agnode, sym->index, "expand");
/* Set an attribute - in this case one that affects the visible rendering */
if (!(sym = agfindattr(plugin->graph->proto->n, "shape")))
sym = agnodeattr(plugin->graph, "shape", "");
agxset(cls_node->agnode, sym->index, "box");
if (!(sym = agfindattr(plugin->graph->proto->n, "label")))
sym = agnodeattr(plugin->graph, "label", "");
agxset(cls_node->agnode, sym->index, cls_node->sym_name);
return cls_node;
}
int
dt_gui_gtk_init(dt_gui_gtk_t *gui, int argc, char *argv[])
{
// unset gtk rc from kde:
char gtkrc[PATH_MAX], path[PATH_MAX], datadir[PATH_MAX], configdir[PATH_MAX];
dt_loc_get_datadir(datadir, PATH_MAX);
dt_loc_get_user_config_dir(configdir, PATH_MAX);
g_snprintf(gtkrc, PATH_MAX, "%s/darktable.gtkrc", configdir);
if (!g_file_test(gtkrc, G_FILE_TEST_EXISTS))
g_snprintf(gtkrc, PATH_MAX, "%s/darktable.gtkrc", datadir);
if (g_file_test(gtkrc, G_FILE_TEST_EXISTS))
(void)setenv("GTK2_RC_FILES", gtkrc, 1);
else
fprintf(stderr, "[gtk_init] could not found darktable.gtkrc");
/* lets zero mem */
memset(gui,0,sizeof(dt_gui_gtk_t));
#if GLIB_MAJOR_VERSION <= 2
#if GLIB_MINOR_VERSION < 31
if (!g_thread_supported ()) g_thread_init(NULL);
#endif
#endif
gdk_threads_init();
gdk_threads_enter();
gtk_init (&argc, &argv);
GtkWidget *widget;
gui->ui = dt_ui_initialize(argc,argv);
gui->pixmap = NULL;
gui->center_tooltip = 0;
gui->presets_popup_menu = NULL;
if(g_file_test(gtkrc, G_FILE_TEST_EXISTS))
gtk_rc_parse (gtkrc);
// Initializing the shortcut groups
darktable.control->accelerators = gtk_accel_group_new();
darktable.control->accelerator_list = NULL;
// Connecting the callback to update keyboard accels for key_pressed
g_signal_connect(G_OBJECT(gtk_accel_map_get()),
"changed",
G_CALLBACK(key_accel_changed),
NULL);
// Initializing widgets
init_widgets();
// Adding the global shortcut group to the main window
gtk_window_add_accel_group(GTK_WINDOW(dt_ui_main_window(darktable.gui->ui)),
darktable.control->accelerators);
// get the screen resolution
gui->dpi = gdk_screen_get_resolution(gtk_widget_get_screen(GTK_WIDGET(dt_ui_main_window(darktable.gui->ui))));
// set constant width from conf key
int panel_width = dt_conf_get_int("panel_width");
if(panel_width < 20 || panel_width > 500)
{
// fix for unset/insane values.
panel_width = 300;
dt_conf_set_int("panel_width", panel_width);
}
// dt_gui_background_jobs_init();
/* Have the delete event (window close) end the program */
dt_loc_get_datadir(datadir, PATH_MAX);
snprintf(path, PATH_MAX, "%s/icons", datadir);
gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (), path);
widget = dt_ui_center(darktable.gui->ui);
g_signal_connect (G_OBJECT (widget), "key-press-event",
G_CALLBACK (key_pressed), NULL);
g_signal_connect (G_OBJECT (widget), "configure-event",
G_CALLBACK (configure), NULL);
g_signal_connect (G_OBJECT (widget), "expose-event",
G_CALLBACK (expose), NULL);
g_signal_connect (G_OBJECT (widget), "motion-notify-event",
G_CALLBACK (mouse_moved), NULL);
g_signal_connect (G_OBJECT (widget), "leave-notify-event",
G_CALLBACK (center_leave), NULL);
g_signal_connect (G_OBJECT (widget), "enter-notify-event",
G_CALLBACK (center_enter), NULL);
g_signal_connect (G_OBJECT (widget), "button-press-event",
G_CALLBACK (button_pressed), NULL);
g_signal_connect (G_OBJECT (widget), "button-release-event",
G_CALLBACK (button_released), NULL);
g_signal_connect (G_OBJECT (widget), "scroll-event",
G_CALLBACK (scrolled), NULL);
// TODO: left, right, top, bottom:
//leave-notify-event
widget = darktable.gui->widgets.left_border;
g_signal_connect (G_OBJECT (widget), "expose-event", G_CALLBACK (expose_borders), (gpointer)0);
g_signal_connect (G_OBJECT (widget), "button-press-event", G_CALLBACK (borders_button_pressed), darktable.gui->ui);
g_signal_connect (G_OBJECT (widget), "scroll-event", G_CALLBACK (borders_scrolled), (gpointer)0);
g_object_set_data(G_OBJECT (widget), "border", (gpointer)0);
widget = darktable.gui->widgets.right_border;
g_signal_connect (G_OBJECT (widget), "expose-event", G_CALLBACK (expose_borders), (gpointer)1);
g_signal_connect (G_OBJECT (widget), "button-press-event", G_CALLBACK (borders_button_pressed), darktable.gui->ui);
g_signal_connect (G_OBJECT (widget), "scroll-event", G_CALLBACK (borders_scrolled), (gpointer)1);
g_object_set_data(G_OBJECT (widget), "border", (gpointer)1);
widget = darktable.gui->widgets.top_border;
g_signal_connect (G_OBJECT (widget), "expose-event", G_CALLBACK (expose_borders), (gpointer)2);
g_signal_connect (G_OBJECT (widget), "button-press-event", G_CALLBACK (borders_button_pressed), darktable.gui->ui);
g_signal_connect (G_OBJECT (widget), "scroll-event", G_CALLBACK (borders_scrolled), (gpointer)2);
g_object_set_data(G_OBJECT (widget), "border", (gpointer)2);
widget = darktable.gui->widgets.bottom_border;
g_signal_connect (G_OBJECT (widget), "expose-event", G_CALLBACK (expose_borders), (gpointer)3);
g_signal_connect (G_OBJECT (widget), "button-press-event", G_CALLBACK (borders_button_pressed), darktable.gui->ui);
g_signal_connect (G_OBJECT (widget), "scroll-event", G_CALLBACK (borders_scrolled), (gpointer)3);
g_object_set_data(G_OBJECT (widget), "border", (gpointer)3);
dt_gui_presets_init();
widget = dt_ui_center(darktable.gui->ui);
GTK_WIDGET_UNSET_FLAGS (widget, GTK_DOUBLE_BUFFERED);
// GTK_WIDGET_SET_FLAGS (widget, GTK_DOUBLE_BUFFERED);
GTK_WIDGET_SET_FLAGS (widget, GTK_APP_PAINTABLE);
// TODO: make this work as: libgnomeui testgnome.c
/* GtkContainer *box = GTK_CONTAINER(darktable.gui->widgets.plugins_vbox);
GtkScrolledWindow *swin = GTK_SCROLLED_WINDOW(darktable.gui->
widgets.right_scrolled_window);
gtk_container_set_focus_vadjustment (box, gtk_scrolled_window_get_vadjustment (swin));
*/
dt_ctl_get_display_profile(widget, &darktable.control->xprofile_data, &darktable.control->xprofile_size);
// register keys for view switching
dt_accel_register_global(NC_("accel", "capture view"), GDK_t, 0);
dt_accel_register_global(NC_("accel", "lighttable view"), GDK_l, 0);
dt_accel_register_global(NC_("accel", "darkroom view"), GDK_d, 0);
dt_accel_connect_global(
"capture view",
g_cclosure_new(G_CALLBACK(_gui_switch_view_key_accel_callback),
(gpointer)DT_GUI_VIEW_SWITCH_TO_TETHERING, NULL));
dt_accel_connect_global(
"lighttable view",
g_cclosure_new(G_CALLBACK(_gui_switch_view_key_accel_callback),
(gpointer)DT_GUI_VIEW_SWITCH_TO_LIBRARY, NULL));
dt_accel_connect_global(
"darkroom view",
g_cclosure_new(G_CALLBACK(_gui_switch_view_key_accel_callback),
(gpointer)DT_GUI_VIEW_SWITCH_TO_DARKROOM, NULL));
// register_keys for applying styles
init_styles_key_accels();
connect_styles_key_accels();
// register ctrl-q to quit:
dt_accel_register_global(NC_("accel", "quit"), GDK_q, GDK_CONTROL_MASK);
dt_accel_connect_global(
"quit",
g_cclosure_new(G_CALLBACK(quit_callback), NULL, NULL));
// Contrast and brightness accelerators
dt_accel_register_global(NC_("accel", "increase brightness"),
GDK_F10, 0);
dt_accel_register_global(NC_("accel", "decrease brightness"),
GDK_F9, 0);
dt_accel_register_global(NC_("accel", "increase contrast"),
GDK_F8, 0);
dt_accel_register_global(NC_("accel", "decrease contrast"),
GDK_F7, 0);
dt_accel_connect_global(
"increase brightness",
g_cclosure_new(G_CALLBACK(brightness_key_accel_callback),
(gpointer)1, NULL));
dt_accel_connect_global(
"decrease brightness",
g_cclosure_new(G_CALLBACK(brightness_key_accel_callback),
(gpointer)0, NULL));
dt_accel_connect_global(
"increase contrast",
g_cclosure_new(G_CALLBACK(contrast_key_accel_callback),
(gpointer)1, NULL));
dt_accel_connect_global(
"decrease contrast",
g_cclosure_new(G_CALLBACK(contrast_key_accel_callback),
(gpointer)0, NULL));
// Full-screen accelerators
dt_accel_register_global(NC_("accel", "toggle fullscreen"), GDK_F11, 0);
dt_accel_register_global(NC_("accel", "leave fullscreen"), GDK_Escape, 0);
dt_accel_connect_global(
"toggle fullscreen",
g_cclosure_new(G_CALLBACK(fullscreen_key_accel_callback),
(gpointer)1, NULL));
dt_accel_connect_global(
"leave fullscreen",
g_cclosure_new(G_CALLBACK(fullscreen_key_accel_callback),
(gpointer)0, NULL));
// Side-border hide/show
dt_accel_register_global(NC_("accel", "toggle side borders"), GDK_Tab, 0);
// toggle view of header
dt_accel_register_global(NC_("accel", "toggle header"),
GDK_h, GDK_CONTROL_MASK);
// View-switch
dt_accel_register_global(NC_("accel", "switch view"), GDK_period, 0);
dt_accel_connect_global(
"switch view",
g_cclosure_new(G_CALLBACK(view_switch_key_accel_callback), NULL, NULL));
darktable.gui->reset = 0;
for(int i=0; i<3; i++) darktable.gui->bgcolor[i] = 0.1333;
/* apply contrast to theme */
dt_gui_contrast_init ();
return 0;
}
/**
* Initialize GTK interface.
*/
static void gui_init(int argc, char** argv, char **respath)
{
char buf[PATH_MAX];
const char *addr = NETSURF_HOMEPAGE;
char *resource_filename;
/* check user options */
check_options(respath);
/* find the languages file */
languages_file_location = filepath_find(respath, "languages");
if ((languages_file_location == NULL) ||
(strlen(languages_file_location) < 10)) {
die("Unable to find resources.\n");
}
/* Obtain resources path location.
*
* Uses the directory the languages file was found in,
* @todo find and slaughter all references to this!
*/
res_dir_location = calloc(1, strlen(languages_file_location) - 8);
memcpy(res_dir_location,
languages_file_location,
strlen(languages_file_location) - 9);
LOG(("Using '%s' for resource path", res_dir_location));
/* initialise the glade templates */
nsgtk_init_glade(respath);
/* set default icon if its available */
resource_filename = filepath_find(respath, "netsurf.xpm");
if (resource_filename != NULL) {
gtk_window_set_default_icon_from_file(resource_filename, NULL);
free(resource_filename);
}
/* Search engine sources */
search_engines_file_location = filepath_find(respath, "SearchEngines");
LOG(("Using '%s' as Search Engines file", search_engines_file_location));
/* Default Icon */
search_default_ico_location = filepath_find(respath, "default.ico");
LOG(("Using '%s' as default search ico", search_default_ico_location));
/* Default favicon */
resource_filename = filepath_find(respath, "favicon.png");
if (resource_filename != NULL) {
favicon_pixbuf = gdk_pixbuf_new_from_file(resource_filename, NULL);
free(resource_filename);
if (favicon_pixbuf == NULL) {
favicon_pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, false, 8, 16,16);
}
}
/* Toolbar inicies file */
toolbar_indices_file_location = filepath_find(respath, "toolbarIndices");
LOG(("Using '%s' as custom toolbar settings file", toolbar_indices_file_location));
/* load throbber images */
if (nsgtk_throbber_init(respath, THROBBER_FRAMES) == false)
die("Unable to load throbber image.\n");
/* Initialise completions - cannot fail */
nsgtk_completion_init();
filepath_sfinddef(respath, buf, "mime.types", "/etc/");
gtk_fetch_filetype_init(buf);
urldb_load(nsoption_charp(url_file));
urldb_load_cookies(nsoption_charp(cookie_file));
/* The tree view system needs to know the screen's DPI, so we
* find that out here, rather than when we create a first browser
* window.
*/
nscss_screen_dpi = FLTTOFIX(gdk_screen_get_resolution(
gdk_screen_get_default()));
LOG(("Set CSS DPI to %f", FIXTOFLT(nscss_screen_dpi)));
if (nsgtk_history_init(glade_file_location->history) == false)
die("Unable to initialise history window.\n");
if (nsgtk_download_init(glade_file_location->downloads) == false)
die("Unable to initialise download window.\n");
if (nsgtk_cookies_init(glade_file_location->cookies) == false)
die("Unable to initialise cookies window.\n");
if (nsgtk_hotlist_init(glade_file_location->hotlist) == false)
die("Unable to initialise hotlist window.\n");
sslcert_init(tree_content_icon_name);
if (nsoption_charp(homepage_url) != NULL) {
addr = nsoption_charp(homepage_url);
}
if (2 <= argc)
addr = argv[1];
/* Last step of initialization. Opens the main browser window. */
browser_window_create(addr, 0, 0, true, false);
}
/**
* Initialize GTK interface.
*/
static nserror nsgtk_init(int argc, char** argv, char **respath)
{
char buf[PATH_MAX];
char *resource_filename;
char *addr = NULL;
nsurl *url;
nserror error;
error = nsgtk_builder_new_from_resname("warning", &warning_builder);
if (error != NSERROR_OK) {
LOG("Unable to initialise warning dialog");
return error;
}
gtk_builder_connect_signals(warning_builder, NULL);
/* set default icon if its available */
error = nsgdk_pixbuf_new_from_resname("netsurf.xpm",
&win_default_icon_pixbuf);
if (error == NSERROR_OK) {
LOG("Seting default window icon");
gtk_window_set_default_icon(win_default_icon_pixbuf);
}
/* Search engine sources */
resource_filename = filepath_find(respath, "SearchEngines");
search_web_init(resource_filename);
if (resource_filename != NULL) {
LOG("Using '%s' as Search Engines file", resource_filename);
free(resource_filename);
}
/* Default favicon */
error = nsgdk_pixbuf_new_from_resname("favicon.png", &favicon_pixbuf);
if (error != NSERROR_OK) {
favicon_pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
false, 8, 16, 16);
}
/* arrow down icon */
error = nsgdk_pixbuf_new_from_resname("arrow_down_8x32.png",
&arrow_down_pixbuf);
if (error != NSERROR_OK) {
arrow_down_pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
false, 8, 8, 32);
}
/* initialise throbber */
error = nsgtk_throbber_init();
if (error != NSERROR_OK) {
LOG("Unable to initialise throbber.");
return error;
}
/* Initialise completions - cannot fail */
nsgtk_completion_init();
filepath_sfinddef(respath, buf, "mime.types", "/etc/");
gtk_fetch_filetype_init(buf);
save_complete_init();
urldb_load(nsoption_charp(url_file));
urldb_load_cookies(nsoption_charp(cookie_file));
/* The tree view system needs to know the screen's DPI, so we
* find that out here, rather than when we create a first browser
* window.
*/
browser_set_dpi(gdk_screen_get_resolution(gdk_screen_get_default()));
LOG("Set CSS DPI to %d", browser_get_dpi());
/* Initialise top level UI elements */
error = nsgtk_download_init();
if (error != NSERROR_OK) {
LOG("Unable to initialise download window.");
return error;
}
/* If there is a url specified on the command line use it */
if (argc > 1) {
struct stat fs;
if (stat(argv[1], &fs) == 0) {
size_t addrlen;
char *rp = realpath(argv[1], NULL);
assert(rp != NULL);
/* calculate file url length including terminator */
addrlen = SLEN("file://") + strlen(rp) + 1;
addr = malloc(addrlen);
assert(addr != NULL);
snprintf(addr, addrlen, "file://%s", rp);
free(rp);
} else {
addr = strdup(argv[1]);
}
}
if (addr != NULL) {
/* managed to set up based on local launch */
} else if (nsoption_charp(homepage_url) != NULL) {
addr = strdup(nsoption_charp(homepage_url));
} else {
addr = strdup(NETSURF_HOMEPAGE);
}
/* create an initial browser window */
error = nsurl_create(addr, &url);
if (error == NSERROR_OK) {
error = browser_window_create(BW_CREATE_HISTORY,
url,
NULL,
NULL,
NULL);
nsurl_unref(url);
}
free(addr);
return error;
}
static GObject * ddb_equalizer_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
GObject * obj;
GObjectClass * parent_class;
DdbEqualizer * self;
parent_class = G_OBJECT_CLASS (ddb_equalizer_parent_class);
obj = parent_class->constructor (type, n_construct_properties, construct_properties);
self = DDB_EQUALIZER (obj);
{
self->priv->margin_bottom = (gint) (((pango_units_to_double (pango_font_description_get_size (gtk_widget_get_style ((GtkWidget*) self)->font_desc)) * gdk_screen_get_resolution (gdk_screen_get_default ())) / 72) + 4);
self->priv->margin_left = self->priv->margin_bottom * 4;
}
return obj;
}
