void
content_draw (GtkWidget *widget,
cairo_t *cr)
{
PangoContext *context;
PangoLayout *title_layout;
PangoLayout *sub_layout;
PangoFontDescription *desc;
int width, height;
int sub_width;
width = gdk_window_get_width (gtk_widget_get_window (widget));
height = gdk_window_get_height (gtk_widget_get_window (widget));
cairo_translate (cr, width / 2, height / 2);
context = gdk_pango_context_get_for_screen (gtk_widget_get_screen (widget));
title_layout = pango_layout_new (context);
pango_layout_set_text (title_layout, _("This session is locked"), -1);
desc = pango_font_description_from_string (TITLE_FONT);
pango_layout_set_font_description (title_layout, desc);
pango_font_description_free (desc);
cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 1.0);
pango_cairo_update_layout (cr, title_layout);
pango_layout_get_size (title_layout, &width, &height);
cairo_save (cr);
/* Adjust the translation to the middle left of the icon */
cairo_translate (cr, - width / PANGO_SCALE / 2 - height / PANGO_SCALE, - height / PANGO_SCALE / 2);
draw_lock_icon (cr, height / PANGO_SCALE);
cairo_restore (cr);
cairo_move_to (cr, - width / PANGO_SCALE / 2 + height / PANGO_SCALE, - height / PANGO_SCALE);
pango_cairo_show_layout (cr, title_layout);
g_object_unref (title_layout);
sub_layout = pango_layout_new (context);
pango_layout_set_text (sub_layout, _("You'll be redirected to the unlock dialog automatically in a few seconds"), -1);
pango_layout_set_wrap (sub_layout, PANGO_WRAP_WORD_CHAR);
pango_layout_set_width (sub_layout, width + 2 * height);
desc = pango_font_description_from_string (MESSAGE_FONT);
pango_layout_set_font_description (sub_layout, desc);
pango_font_description_free (desc);
cairo_set_source_rgba (cr, 0.6, 0.6, 0.6, 1.0);
pango_cairo_update_layout (cr, sub_layout);
pango_layout_get_size (sub_layout, &sub_width, NULL);
cairo_move_to (cr, - (width + 2 * height) / PANGO_SCALE / 2, height / PANGO_SCALE);
cairo_scale (cr, (width + 2 * height) / (gdouble)sub_width, (width + 2 * height) / (gdouble)sub_width);
pango_cairo_show_layout (cr, sub_layout);
g_object_unref (sub_layout);
g_object_unref (context);
}
static void
workrave_timebar_init_ui(WorkraveTimebar *self)
{
WorkraveTimebarPrivate *priv = WORKRAVE_TIMEBAR_GET_PRIVATE(self);
priv->style_context = gtk_style_context_new();
GtkWidgetPath *path = gtk_widget_path_new();
gtk_widget_path_append_type(path, GTK_TYPE_BUTTON);
gtk_style_context_set_path(priv->style_context, path);
gtk_style_context_add_class(priv->style_context, GTK_STYLE_CLASS_TROUGH);
GdkScreen *screen = gdk_screen_get_default();
priv->pango_context = gdk_pango_context_get_for_screen(screen);
const PangoFontDescription *font_desc = gtk_style_context_get_font(priv->style_context, GTK_STATE_FLAG_ACTIVE);
pango_context_set_language(priv->pango_context, gtk_get_default_language());
pango_context_set_font_description(priv->pango_context, font_desc);
priv->pango_layout = pango_layout_new(priv->pango_context);
pango_layout_set_text(priv->pango_layout, "-9:59:59", -1);
pango_layout_get_pixel_size(priv->pango_layout, &priv->width, &priv->height);
priv->width = MAX(priv->width + 2 * MARGINX, MIN_HORIZONTAL_BAR_WIDTH);
priv->height = MAX(priv->height + 2 * MARGINY, MIN_HORIZONTAL_BAR_HEIGHT);
gtk_widget_path_free(path);
}
static gboolean
file_view_query_tooltip (GtkWidget* widget, gint x, gint y, gboolean keyboard,
GtkTooltip* tooltip)
{
AnjutaFileView* view = ANJUTA_FILE_VIEW (widget);
AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (view);
GtkTreeModel* model_sort;
GtkTreeModel* file_model = GTK_TREE_MODEL (priv->model);
GtkTreePath* path;
GtkTreeIter iter;
GtkTreeIter real_iter;
gchar* filename;
gboolean result = TRUE;
GdkRectangle visible_rect, column_rect;
GdkScreen *screen = gdk_screen_get_default ();
PangoContext *context;
PangoLayout *layout;
gint width, height;
if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (view),
&x, &y, keyboard,
&model_sort,
&path,
&iter))
return FALSE;
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model_sort),
&real_iter, &iter);
filename = file_model_get_filename (FILE_MODEL (file_model), &real_iter);
context = gdk_pango_context_get_for_screen (screen);
layout = pango_layout_new (context);
pango_layout_set_text (layout, filename, -1);
pango_layout_get_pixel_size (layout, &width, &height);
gtk_tree_view_get_visible_rect (GTK_TREE_VIEW (view), &visible_rect);
gtk_tree_view_get_cell_area (GTK_TREE_VIEW (view), path,
gtk_tree_view_get_column (GTK_TREE_VIEW (view), 0), &column_rect);
if (column_rect.x + width > visible_rect.x + visible_rect.width ||
column_rect.x < visible_rect.x)
{
gtk_tooltip_set_text (tooltip, filename);
gtk_tree_view_set_tooltip_row (GTK_TREE_VIEW (view),
tooltip,
path);
} else
{
result = FALSE;
}
g_free (filename);
gtk_tree_path_free (path);
g_object_unref (layout);
g_object_unref (context);
return result;
}
static PangoLayout *
get_pango_layout (GtkNumerableIcon *self)
{
PangoContext *context;
GdkScreen *screen;
PangoLayout *layout;
if (self->priv->style != NULL)
{
screen = gtk_style_context_get_screen (self->priv->style);
context = gdk_pango_context_get_for_screen (screen);
layout = pango_layout_new (context);
if (self->priv->font != NULL)
pango_layout_set_font_description (layout, self->priv->font);
pango_layout_set_text (layout, self->priv->rendered_string, -1);
g_object_unref (context);
}
else
{
GtkWidget *fake;
/* steal gtk text settings from the window */
fake = gtk_window_new (GTK_WINDOW_TOPLEVEL);
layout = gtk_widget_create_pango_layout (fake, self->priv->rendered_string);
gtk_widget_destroy (fake);
}
return layout;
}
wxFontProperties::wxFontProperties(wxFont* font):
m_ascent(0), m_descent(0), m_lineGap(0), m_lineSpacing(0), m_xHeight(0)
{
PangoContext* context = gdk_pango_context_get_for_screen( gdk_screen_get_default() );
PangoLayout* layout = pango_layout_new(context);
// and use it if it's valid
if ( font && font->Ok() )
{
pango_layout_set_font_description
(
layout,
font->GetNativeFontInfo()->description
);
}
PangoFontMetrics* metrics = pango_context_get_metrics (context, font->GetNativeFontInfo()->description, NULL);
int height = font->GetPixelSize().GetHeight();
m_ascent = PANGO_PIXELS(pango_font_metrics_get_ascent(metrics));
m_descent = PANGO_PIXELS(pango_font_metrics_get_descent(metrics));
int h;
const char* x = "x";
pango_layout_set_text( layout, x, strlen(x) );
pango_layout_get_pixel_size( layout, NULL, &h );
m_xHeight = h;
m_lineGap = (m_ascent + m_descent) / 4; // FIXME: How can we calculate this via Pango?
m_lineSpacing = m_ascent + m_descent;
pango_font_metrics_unref(metrics);
}
void GetTextExtent( const wxFont& font, const wxString& str, wxCoord *width, wxCoord *height,
wxCoord *descent, wxCoord *externalLeading )
{
if ( width )
*width = 0;
if ( height )
*height = 0;
if ( descent )
*descent = 0;
if ( externalLeading )
*externalLeading = 0;
if (str.empty())
return;
PangoContext* context = gdk_pango_context_get_for_screen( gdk_screen_get_default() );
PangoLayout* m_layout = pango_layout_new(context);
// and use it if it's valid
if ( font != wxNullFont )
{
pango_layout_set_font_description
(
m_layout,
font.GetNativeFontInfo()->description
);
}
// Set layout's text
const wxCharBuffer dataUTF8 = wxConvUTF8.cWX2MB(str);
if ( !dataUTF8 )
{
// hardly ideal, but what else can we do if conversion failed?
return;
}
pango_layout_set_text( m_layout, dataUTF8, strlen(dataUTF8) );
if (descent)
{
int h;
pango_layout_get_pixel_size( m_layout, width, &h );
PangoLayoutIter *iter = pango_layout_get_iter(m_layout);
int baseline = pango_layout_iter_get_baseline(iter);
pango_layout_iter_free(iter);
*descent = h - PANGO_PIXELS(baseline);
if (height)
*height = (wxCoord) h;
}
else
{
pango_layout_get_pixel_size( m_layout, width, height );
}
// Reset old font description
//if (font != wxNullFont)
// pango_layout_set_font_description( m_layout, m_fontdesc );
}
Size pFont::size(PangoFontDescription* font, string text) {
PangoContext* context = gdk_pango_context_get_for_screen(gdk_screen_get_default());
PangoLayout* layout = pango_layout_new(context);
pango_layout_set_font_description(layout, font);
pango_layout_set_text(layout, text, -1);
int width = 0, height = 0;
pango_layout_get_pixel_size(layout, &width, &height);
g_object_unref((gpointer)layout);
return {width, height};
}
/**
* @brief Callback when vfo B is created
*
* @param widget
* @param event
*
* @return
*/
gboolean vfoBFrequency_configure_event(GtkWidget* widget,GdkEventConfigure* event) {
GdkGC* gc;
PangoContext *context;
PangoLayout *layout;
char temp[128];
if(vfoBPixmap) g_object_unref(vfoBPixmap);
vfoBPixmap=gdk_pixmap_new(widget->window,widget->allocation.width,widget->allocation.height,-1);
gc=gdk_gc_new(widget->window);
gdk_gc_set_rgb_fg_color(gc,&background);
gdk_draw_rectangle(vfoBPixmap,
gc,
TRUE,
0,0,
widget->allocation.width,
widget->allocation.height);
context = gdk_pango_context_get_for_screen (gdk_screen_get_default ());
layout = pango_layout_new (context);
pango_layout_set_width(layout,widget->allocation.width*PANGO_SCALE);
pango_layout_set_alignment(layout,PANGO_ALIGN_RIGHT);
#ifdef NETBOOK
sprintf(temp,"<span foreground='#C0C0C0' background='#2C2C2C' font_desc='Sans Bold 12'>% 7lld.%03lld.%03lld </span>",frequencyB/1000000LL,(frequencyB%1000000LL)/1000LL,frequencyB%1000LL);
#else
sprintf(temp,"<span foreground='#C0C0C0' background='#2C2C2C' font_desc='Sans Bold 20'>% 7lld.%03lld.%03lld </span>",frequencyB/1000000LL,(frequencyB%1000000LL)/1000LL,frequencyB%1000LL);
#endif
pango_layout_set_markup(layout,temp,-1);
gdk_draw_layout(GDK_DRAWABLE(vfoBPixmap),gc,0,0,layout);
gdk_gc_set_rgb_fg_color(gc,&grey);
gdk_draw_rectangle(vfoBPixmap,
gc,
FALSE,
0,0,
widget->allocation.width-1,
widget->allocation.height-1);
g_object_unref(context);
g_object_unref(layout);
g_object_unref(gc);
return TRUE;
}
static VALUE
gdkpango_s_context_get(int argc, VALUE *argv, VALUE self)
{
VALUE screen, ret;
rb_scan_args(argc, argv, "01", &screen);
if (NIL_P(screen)){
ret = GOBJ2RVAL(gdk_pango_context_get());
} else {
#if GTK_CHECK_VERSION(2,2,0)
ret = GOBJ2RVAL(gdk_pango_context_get_for_screen(GDK_SCREEN(RVAL2GOBJ(screen))));
#else
rb_warn("Gdk::Pango.context_get: Not supported arguments in GTK+-2.0.x.");
ret = GOBJ2RVAL(gdk_pango_context_get());
#endif
}
return ret;
}
static int setup_fonts(void)
{
int width, height;
GdkDrawable *drawable=GDK_DRAWABLE(gtk_widget_get_root_window(GTK_WIDGET(GLOBALS->mainwindow)));
GdkScreen *fonts_screen = gdk_drawable_get_screen (drawable);
GLOBALS->fonts_renderer = gdk_pango_renderer_get_default (fonts_screen);
gdk_pango_renderer_set_drawable (GDK_PANGO_RENDERER (GLOBALS->fonts_renderer), drawable);
GLOBALS->fonts_gc = gdk_gc_new (drawable);
gdk_pango_renderer_set_gc (GDK_PANGO_RENDERER (GLOBALS->fonts_renderer), GLOBALS->fonts_gc);
gdk_drawable_get_size (drawable, &width, &height);
GLOBALS->fonts_context = gdk_pango_context_get_for_screen (fonts_screen);
GLOBALS->fonts_layout = pango_layout_new (GLOBALS->fonts_context);
return 0;
}
/**
* @brief update vfo b display
*
* @param widget
* @param event
*
* @return
*/
void updateVfoBDisplay() {
GdkGC* gc;
PangoContext *context;
PangoLayout *layout;
char temp[128];
if(vfoBFrequency->window) {
gc=gdk_gc_new(vfoBFrequency->window);
gdk_gc_set_rgb_fg_color(gc,&background);
gdk_draw_rectangle(vfoBPixmap,
gc,
TRUE,
0,0,
vfoBFrequency->allocation.width,
vfoBFrequency->allocation.height);
context = gdk_pango_context_get_for_screen (gdk_screen_get_default ());
layout = pango_layout_new (context);
pango_layout_set_width(layout,vfoBFrequency->allocation.width*PANGO_SCALE);
pango_layout_set_alignment(layout,PANGO_ALIGN_RIGHT);
#ifdef NETBOOK
sprintf(temp,"<span foreground='%s' background='#2C2C2C' font_desc='Sans Bold 12'>% 7lld.%03lld.%03lld </span>",bTransmitting?"#FF0000":"#C0C0C0",frequencyB/1000000LL,(frequencyB%1000000LL)/1000LL,frequencyB%1000LL);
#else
sprintf(temp,"<span foreground='%s' background='#2C2C2C' font_desc='Sans Bold 20'>% 7lld.%03lld.%03lld </span>",bTransmitting?"#FF0000":"#C0C0C0",frequencyB/1000000LL,(frequencyB%1000000LL)/1000LL,frequencyB%1000LL);
#endif
pango_layout_set_markup(layout,temp,-1);
gdk_draw_layout(GDK_DRAWABLE(vfoBPixmap),gc,0,0,layout);
gdk_gc_set_rgb_fg_color(gc,&grey);
gdk_draw_rectangle(vfoBPixmap,
gc,
FALSE,
0,0,
vfoBFrequency->allocation.width-1,
vfoBFrequency->allocation.height-1);
g_object_unref(context);
g_object_unref(layout);
g_object_unref(gc);
gtk_widget_queue_draw(vfoBFrequency);
}
}
/**
* gnm_pango_context_get:
*
* Simple wrapper to handle windowless operation
* Returns: (transfer full):
**/
PangoContext *
gnm_pango_context_get (void)
{
if (!context) {
GdkScreen *screen = gdk_screen_get_default ();
if (screen != NULL) {
context = gdk_pango_context_get_for_screen (screen);
} else {
if (!fontmap)
fontmap = pango_cairo_font_map_new ();
pango_cairo_font_map_set_resolution (PANGO_CAIRO_FONT_MAP (fontmap), 96);
context = pango_font_map_create_context (PANGO_FONT_MAP (fontmap));
}
pango_context_set_language (context, gtk_get_default_language ());
pango_context_set_base_dir (context, PANGO_DIRECTION_LTR);
}
return g_object_ref (context);
}
/****************************************************************************
Return the size of the given text in the given font. This size should
include the ascent and descent of the text. Either of width or height
may be NULL in which case those values simply shouldn't be filled out.
****************************************************************************/
void get_text_size(int *width, int *height,
enum client_font font, const char *text)
{
PangoRectangle rect;
if (!layout) {
layout = pango_layout_new(gdk_pango_context_get_for_screen(gdk_screen_get_default()));
}
pango_layout_set_font_description(layout, FONT(font));
pango_layout_set_text(layout, text, -1);
pango_layout_get_pixel_extents(layout, NULL, &rect);
if (width) {
*width = rect.width;
}
if (height) {
*height = rect.height;
}
}
static void
workrave_timebar_init_ui(WorkraveTimebar *self)
{
WorkraveTimebarPrivate *priv = WORKRAVE_TIMEBAR_GET_PRIVATE(self);
GdkScreen *screen = gdk_screen_get_default();
priv->pango_context = gdk_pango_context_get_for_screen(screen);
const PangoFontDescription *font_desc = pango_font_description_from_string("Sans 10");
pango_context_set_language(priv->pango_context, gtk_get_default_language());
pango_context_set_font_description(priv->pango_context, font_desc);
priv->pango_layout = pango_layout_new(priv->pango_context);
pango_layout_set_text(priv->pango_layout, "-9:59:59", -1);
pango_layout_get_pixel_size(priv->pango_layout, &priv->width, &priv->height);
priv->width = MAX(priv->width + 2 * MARGINX, MIN_HORIZONTAL_BAR_WIDTH);
priv->height = MAX(priv->height + 2 * MARGINY, MIN_HORIZONTAL_BAR_HEIGHT);
}
/****************************************************************************
Draw the text onto the canvas in the given color and font. The canvas
position does not account for the ascent of the text; this function must
take care of this manually. The text will not be NULL but may be empty.
****************************************************************************/
void canvas_put_text(struct canvas *pcanvas, int canvas_x, int canvas_y,
enum client_font font,
struct color *pcolor,
const char *text)
{
cairo_t *cr;
if (!layout) {
layout = pango_layout_new(gdk_pango_context_get_for_screen(gdk_screen_get_default()));
}
if (!pcanvas->drawable) {
cr = cairo_create(pcanvas->surface);
} else {
cr = pcanvas->drawable;
}
if (pcanvas->drawable) {
cairo_save(cr);
}
pango_layout_set_font_description(layout, FONT(font));
pango_layout_set_text(layout, text, -1);
if (fonts[font].shadowed) {
cairo_set_source_rgb(cr, 0, 0, 0);
cairo_move_to(cr, canvas_x * pcanvas->zoom + 1, canvas_y * pcanvas->zoom + 1);
pango_cairo_show_layout (cr, layout);
}
cairo_move_to(cr, canvas_x * pcanvas->zoom, canvas_y * pcanvas->zoom);
gdk_cairo_set_source_rgba(cr, &pcolor->color);
pango_cairo_show_layout(cr, layout);
if (!pcanvas->drawable) {
cairo_destroy(cr);
} else {
cairo_restore(cr);
}
}
/**
* @brief Draw increment display
*
* @param queue
*/
void drawIncrementDisplay(gboolean queue) {
GdkGC* gc;
PangoContext *context;
PangoLayout *layout;
char temp[128];
if(incrementDisplay->window) {
if(incrementPixmap) g_object_unref(incrementPixmap);
incrementPixmap=gdk_pixmap_new(incrementDisplay->window,incrementDisplay->allocation.width,incrementDisplay->allocation.height,-1);
gc=gdk_gc_new(incrementDisplay->window);
gdk_gc_set_rgb_fg_color(gc,&black);
gdk_draw_rectangle(incrementPixmap,
gc,
TRUE,
0,0,
incrementDisplay->allocation.width,
incrementDisplay->allocation.height);
context = gdk_pango_context_get_for_screen (gdk_screen_get_default ());
layout = pango_layout_new (context);
pango_layout_set_width(layout,incrementDisplay->allocation.width*PANGO_SCALE);
pango_layout_set_alignment(layout,PANGO_ALIGN_CENTER);
sprintf(temp,"<span foreground='#7AAA6E' background='#2C2C2C' font_desc='Sans Bold 10'>%0ld</span>",frequencyIncrement);
pango_layout_set_markup(layout,temp,-1);
gdk_draw_layout(GDK_DRAWABLE(incrementPixmap),gc,0,0,layout);
g_object_unref(context);
g_object_unref(layout);
g_object_unref(gc);
if(queue) gtk_widget_queue_draw(incrementDisplay);
}
}
int main( int argc, char *argv[] )
{
#ifdef __HYPHYMPI__
int rank,
size;
MPI_Init (&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
_hy_mpi_node_rank = rank;
setParameter (mpiNodeID, (_Parameter)rank);
setParameter (mpiNodeCount, (_Parameter)size);
if (rank == 0)
#endif
gtk_init (&argc, &argv);
/* set up globals */
char curWd[4096];
getcwd (curWd,4096);
_String baseDir (curWd);
baseDir=baseDir&'/';
pathNames&& &baseDir;
baseDirectory = baseDir;
for (long i=1; i<argc;i++)
{
_String thisArg (argv[i]);
if (thisArg.beginswith ("BASEPATH="))
{
baseDirectory = thisArg.Cut(9,-1);
if (baseDirectory.sLength)
{
if (baseDirectory.sData[baseDirectory.sLength-1]!='/')
baseDirectory = baseDirectory&"/";
}
}
else
if (thisArg.beginswith ("USEPATH="))
{
_String baseArgDir (thisArg,8,-1);
errorFileName = baseArgDir & errorFileName;
messageFileName = baseArgDir & messageFileName;
pathNames.Delete (0);
pathNames&& &baseDir;
}
else
if (thisArg.beginswith ("CPU="))
{
#ifdef __MP__
_String cpus = thisArg.Cut(4,-1);
systemCPUCount = cpus.toNum();
if (systemCPUCount<1)
systemCPUCount = 1;
#ifdef __MP2__
pthread_setconcurrency (systemCPUCount+1);
#endif
#endif
}
#ifdef __HYPHYMPI__
else
if (thisArg == _String("MPIOPTIMIZER"))
{
mpiParallelOptimizer = true;
setParameter (mpiNodeCount, 0.0);
}
else
if (thisArg == _String("MPIPARTITIONS"))
{
mpiPartitionOptimizer = true;
setParameter (mpiNodeCount, 0.0);
}
#endif
}
#ifdef __HYPHYMPI__
if (rank == 0)
#endif
{
baseDir = baseDirectory & "GTKResources";
_List scanRes;
ScanDirectoryForFileNames(baseDir,scanRes,false);
if (scanRes.lLength == 0)
{
GtkWidget * noRez = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "HYPHY_GTK was unable to find a required GTKResources directory in %s. Please use BASEPATH= command line option to specify where the installation directory of HyPhy can be found.", baseDirectory.sData);
gtk_dialog_run (GTK_DIALOG (noRez));
gtk_widget_destroy (noRez);
return 1;
}
_String rcPath = baseDir & "/theme/theme.rc";
//printf ("Loading res files from %s\n", rcPath.sData);
gtk_rc_parse (rcPath.sData);
}
GlobalStartup();
#ifdef __HYPHYMPI__
if (rank == 0)
{
#endif
GdkDisplay * defDisplay = gdk_screen_get_display (gdk_screen_get_default());
hSizeCursor = gdk_cursor_new_for_display (defDisplay,GDK_SB_H_DOUBLE_ARROW);
pickUpCursor = gdk_cursor_new_for_display (defDisplay,GDK_TARGET);
dropOffCursor = gdk_cursor_new_for_display (defDisplay,GDK_TCROSS);
screenPContext = gdk_pango_context_get_for_screen (gdk_screen_get_default());
tablePDMenuIcon = (GdkPixbuf*)ProcureIconResource(4020);
/*{
GdkScreen * defD = gdk_screen_get_default();
fontConversionFactor = 72.27 / (gdk_screen_get_height (defD) *25.4 / gdk_screen_get_height_mm(defD));
printf ("Pango conversion factor computed at: %g\n", fontConversionFactor);
}*/
ReadInTemplateFiles ();
hyphyConsoleWindow = new _HYConsoleWindow ("HYPHY Console");
ReadPreferences ();
SetStatusLine ("None","Idle","00:00:00");
while (gtk_events_pending())
gtk_main_iteration();
SetPreferences ();
ReadGeneticCodes ();
ReadModelTemplates ();
ReadTreeProcessors ();
MoveConsoleWindow (consolePositionRectangle);
StringToConsole (hyphyCiteString);
hyphyConsoleWindow->BringToFront();
#ifdef __HYPHYMPI__
{
char statBuffer[1024];
sprintf (statBuffer,"MPI version of HyPhy running on %d nodes (a master and %d compute nodes) in %s mode\n",
size,
size-1,
mpiPartitionOptimizer?"partition":(mpiParallelOptimizer?"rate heterogeneity":"normal"));
BufferToConsole (statBuffer);
}
#endif
g_timeout_add (100,GlobalQueueTimer,nil);
g_timeout_add (1000,progressTimerFunction,nil);
gtk_main ();
WritePreferences();
#ifdef __HYPHYMPI__
}
else // slave node
{
if (mpiParallelOptimizer || mpiPartitionOptimizer)
mpiOptimizerLoop (rank, size);
else
mpiNormalLoop (rank, size, baseDir);
}
#endif
GlobalShutdown();
return 0;
}
GdkPixbuf*
gwy_graph_export_pixmap(GwyGraph *graph,
G_GNUC_UNUSED gboolean export_title,
G_GNUC_UNUSED gboolean export_axis,
G_GNUC_UNUSED gboolean export_labels)
{
GdkColor color = { 0, 65535, 65535, 65535 };
GdkPixbuf *pixbuf;
GdkColormap *cmap;
GdkGC *gc;
GdkVisual *visual;
GdkPixmap *pixmap;
PangoLayout *layout;
PangoContext *context;
gint width, height, topheight, bottomheight, rightwidth, leftwidth;
gint labelx, labely, labelw, labelh;
width = (GTK_WIDGET(graph))->allocation.width;
height = (GTK_WIDGET(graph))->allocation.height;
topheight = (GTK_WIDGET(graph->axis[GTK_POS_TOP]))->allocation.height;
bottomheight = (GTK_WIDGET(graph->axis[GTK_POS_BOTTOM]))->allocation.height;
leftwidth = (GTK_WIDGET(graph->axis[GTK_POS_LEFT]))->allocation.width;
rightwidth = (GTK_WIDGET(graph->axis[GTK_POS_RIGHT]))->allocation.width;
labelx = (GTK_WIDGET(graph->area->lab))->allocation.x + leftwidth;
labely = (GTK_WIDGET(graph->area->lab))->allocation.y + topheight;
labelw = (GWY_GRAPH_LABEL(graph->area->lab))->reqwidth;
labelh = (GWY_GRAPH_LABEL(graph->area->lab))->reqheight;
visual = gdk_visual_get_best();
cmap = gdk_colormap_new(visual, FALSE);
pixmap = gdk_pixmap_new(NULL, width, height, visual->depth);
gdk_drawable_set_colormap(pixmap, cmap);
gc = gdk_gc_new(pixmap);
gdk_gc_set_colormap(gc, cmap);
gdk_gc_set_rgb_fg_color(gc, &color);
gdk_draw_rectangle(pixmap, gc, TRUE, 0, 0, width, height);
gwy_graph_area_draw_on_drawable(graph->area, pixmap, gc,
leftwidth, topheight,
width - leftwidth - rightwidth,
height - topheight - bottomheight);
/* Draw axes */
gwy_axis_draw_on_drawable(graph->axis[GTK_POS_TOP], pixmap, gc,
leftwidth, 0,
width - leftwidth - rightwidth, topheight);
gwy_axis_draw_on_drawable(graph->axis[GTK_POS_BOTTOM], pixmap, gc,
leftwidth, height - bottomheight,
width - leftwidth - rightwidth, bottomheight);
gwy_axis_draw_on_drawable(graph->axis[GTK_POS_LEFT], pixmap, gc,
0, topheight,
leftwidth, height - topheight - bottomheight);
gwy_axis_draw_on_drawable(graph->axis[GTK_POS_RIGHT], pixmap, gc,
width - rightwidth, topheight,
rightwidth, height - topheight - bottomheight);
context = gdk_pango_context_get_for_screen(gdk_screen_get_default());
pango_context_set_font_description(context, graph->area->lab->font_desc);
layout = pango_layout_new(context);
gwy_graph_label_draw_on_drawable(graph->area->lab, pixmap, gc, layout,
labelx, labely, labelw, labelh);
pixbuf = gdk_pixbuf_get_from_drawable(NULL, pixmap, cmap,
0, 0, 0, 0,
-1, -1);
g_object_unref(pixmap);
g_object_unref(layout);
g_object_unref(context);
g_object_unref(gc);
g_object_unref(cmap);
return pixbuf;
}
void render_text(GdkDrawable *da, GdkGC *gc, int x, int y, double angle,
const char *s, const char *font, double xalign, double yalign,
int xmax, int ymax)
{
GdkScreen *screen;
PangoRenderer *renderer;
PangoContext *context;
PangoLayout *layout;
PangoFontDescription *desc;
int width, height;
PangoMatrix m = PANGO_MATRIX_INIT;
double f_min, f;
/* set up the renderer */
screen = gdk_drawable_get_screen(da);
renderer = gdk_pango_renderer_get_default(screen);
gdk_pango_renderer_set_drawable(GDK_PANGO_RENDERER(renderer), da);
gdk_pango_renderer_set_gc(GDK_PANGO_RENDERER(renderer), gc);
/* start preparing the layout */
context = gdk_pango_context_get_for_screen(screen);
layout = pango_layout_new(context);
pango_layout_set_text(layout, s, -1);
/* apply the font */
desc = pango_font_description_from_string(font);
pango_layout_set_font_description(layout, desc);
pango_font_description_free(desc);
/* align and position the text */
pango_layout_get_size(layout, &width, &height);
f_min = 1.0;
if (xmax) {
f = xmax/((double) width/PANGO_SCALE);
if (f < f_min)
f_min = f;
}
if (ymax) {
f = ymax/((double) height/PANGO_SCALE);
if (f < f_min)
f_min = f;
}
if (f_min < MIN_FONT_SCALE)
f_min = MIN_FONT_SCALE;
pango_matrix_translate(&m, x, y);
pango_matrix_rotate(&m, angle);
pango_matrix_translate(&m,
-xalign*f_min*width/PANGO_SCALE,
(yalign-1)*f_min*height/PANGO_SCALE);
pango_matrix_scale(&m, f_min, f_min);
pango_context_set_matrix(context, &m);
pango_layout_context_changed(layout);
pango_renderer_draw_layout(renderer, layout, 0, 0);
/* clean up renderer */
gdk_pango_renderer_set_drawable(GDK_PANGO_RENDERER(renderer), NULL);
gdk_pango_renderer_set_gc(GDK_PANGO_RENDERER(renderer), NULL);
/* free objects */
g_object_unref(layout);
g_object_unref(context);
}
/**
* gdk_pango_context_get:
*
* Creates a #PangoContext for the default GDK 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 default 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 the default display
**/
PangoContext *
gdk_pango_context_get (void)
{
return gdk_pango_context_get_for_screen (gdk_screen_get_default ());
}
