static void
hippo_canvas_text_get_content_width_request(HippoCanvasBox *box,
int *min_width_p,
int *natural_width_p)
{
HippoCanvasText *text = HIPPO_CANVAS_TEXT(box);
int children_min_width, children_natural_width;
int layout_width;
HIPPO_CANVAS_BOX_CLASS(hippo_canvas_text_parent_class)->get_content_width_request(box,
&children_min_width,
&children_natural_width);
if (box->context != NULL) {
PangoLayout *layout = create_layout(text, -1);
pango_layout_get_size(layout, &layout_width, NULL);
layout_width /= PANGO_SCALE;
g_object_unref(layout);
} else {
layout_width = 0;
}
if (min_width_p) {
if (text->size_mode == HIPPO_CANVAS_SIZE_FULL_WIDTH)
*min_width_p = MAX(children_min_width, layout_width);
else
*min_width_p = children_min_width;
}
if (natural_width_p) {
*natural_width_p = MAX(children_natural_width, layout_width);
}
}
static void
hippo_canvas_text_get_content_height_request(HippoCanvasBox *box,
int for_width,
int *min_height_p,
int *natural_height_p)
{
HippoCanvasText *text = HIPPO_CANVAS_TEXT(box);
int children_min_height, children_natural_height;
PangoLayout *layout;
int layout_height;
HIPPO_CANVAS_BOX_CLASS(hippo_canvas_text_parent_class)->get_content_height_request(box,
for_width,
&children_min_height,
&children_natural_height);
if (for_width > 0) {
if (box->context != NULL) {
layout = create_layout(text, for_width);
pango_layout_get_size(layout, NULL, &layout_height);
layout_height /= PANGO_SCALE;
g_object_unref(layout);
} else {
layout_height = 0;
}
} else {
layout_height = 0;
}
if (min_height_p)
*min_height_p = MAX(layout_height, children_min_height);
if (natural_height_p)
*natural_height_p = MAX(layout_height, children_natural_height);
}
MainWindow::MainWindow(QWidget *parent) : QDialog(parent)
{
create_buttons();
create_tabs();
create_layout();
create_actions();
chosen_file = "";
}
/**
* vik_trw_layer_analyse_this:
* @window: A window from which the dialog will be derived
* @name: The name to be shown
* @vl: The #VikLayer passed on into get_tracks_and_layers_cb()
* @user_data: Data passed on into get_tracks_and_layers_cb()
* @get_tracks_and_layers_cb: The function to call to construct items to be analysed
*
* Display a dialog with stats across many tracks
*
* Returns: The dialog that is created to display the analyse information
*/
GtkWidget* vik_trw_layer_analyse_this ( GtkWindow *window,
const gchar *name,
VikLayer *vl,
gpointer user_data,
VikTrwlayerGetTracksAndLayersFunc get_tracks_and_layers_cb,
VikTrwlayerAnalyseCloseFunc on_close_cb )
{
//VikWindow *vw = VIK_WINDOW(window);
GtkWidget *dialog;
dialog = gtk_dialog_new_with_buttons ( _("Statistics"),
window,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL,
NULL );
GtkWidget *name_l = gtk_label_new ( NULL );
gchar *myname = g_markup_printf_escaped ( "<b>%s</b>", name );
gtk_label_set_markup ( GTK_LABEL(name_l), myname );
g_free ( myname );
GtkWidget *content = gtk_dialog_get_content_area ( GTK_DIALOG(dialog) );
gtk_box_pack_start ( GTK_BOX(content), name_l, FALSE, FALSE, 10);
// Get previous value (if any) from the settings
gboolean include_invisible;
if ( ! a_settings_get_boolean ( VIK_SETTINGS_ANALYSIS_DO_INVISIBLE, &include_invisible ) )
include_invisible = TRUE;
analyse_cb_t *acb = g_malloc (sizeof(analyse_cb_t));
acb->vl = vl;
acb->user_data = user_data;
acb->get_tracks_and_layers_cb = get_tracks_and_layers_cb;
acb->on_close_cb = on_close_cb;
acb->tracks_and_layers = get_tracks_and_layers_cb ( vl, user_data );
acb->widgets = g_malloc ( sizeof(GtkWidget*) * G_N_ELEMENTS(label_texts) );
acb->extended = vl->type == VIK_LAYER_AGGREGATE;
acb->layout = create_layout ( acb->widgets, acb->extended );
gtk_box_pack_start ( GTK_BOX(content), acb->layout, FALSE, FALSE, 0 );
// Analysis seems reasonably quick
// unless you have really large numbers of tracks (i.e. many many thousands or a really slow computer)
// One day might store stats in the track itself....
val_analyse ( acb->widgets, acb->tracks_and_layers, include_invisible, acb->extended );
GtkWidget *cb = gtk_check_button_new_with_label ( _("Include Invisible Items") );
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON(cb), include_invisible );
gtk_box_pack_start ( GTK_BOX(content), cb, FALSE, FALSE, 10);
acb->check_button = cb;
gtk_widget_show_all ( dialog );
g_signal_connect ( G_OBJECT(cb), "toggled", G_CALLBACK(include_invisible_toggled_cb), acb );
g_signal_connect ( G_OBJECT(dialog), "response", G_CALLBACK(analyse_close), acb );
return dialog;
}
//---------------------------------------------------------------------------------------
void ToolPageTopLevel::create_tool_groups()
{
wxBoxSizer *pMainSizer = GetMainSizer();
add_group( LENMUS_NEW GrpTopLevel(this, pMainSizer, k_mouse_mode_data_entry) );
create_layout();
select_group(k_grp_Harmony);
}
Terminal::Terminal(QWidget *parent) : QWidget(parent)
{
create_receive_terminal();
create_transmit_terminal();
create_transmit_editor();
create_transmit_button();
create_layout();
portOpen = false;
autoScroll = false;
}
//---------------------------------------------------------------------------------------
void ToolPageRhythmicDictation::create_tool_groups()
{
wxBoxSizer *pMainSizer = GetMainSizer();
add_group( LENMUS_NEW GrpNoteDuration(this, pMainSizer) );
add_group( LENMUS_NEW GrpNoteDots(this, pMainSizer) );
add_group( LENMUS_NEW GrpBarlines2(this, pMainSizer) );
create_layout();
select_group(k_grp_NoteDuration);
}
TilesetImage::TilesetImage()
: ScrolledWindow()
{
// Always show the scrollbars to prevet changing the size of
// the draw area on larger images
set_policy(Gtk::POLICY_ALWAYS, Gtk::POLICY_ALWAYS);
create_layout();
setup_event_handlers();
show_all_children();
}
VALUE build_class_from_descriptor(Descriptor* desc) {
const char *name;
VALUE klass;
if (desc->layout == NULL) {
desc->layout = create_layout(desc->msgdef);
}
if (desc->fill_method == NULL) {
desc->fill_method = new_fillmsg_decodermethod(desc, &desc->fill_method);
}
name = upb_msgdef_fullname(desc->msgdef);
if (name == NULL) {
rb_raise(rb_eRuntimeError, "Descriptor does not have assigned name.");
}
klass = rb_define_class_id(
// Docs say this parameter is ignored. User will assign return value to
// their own toplevel constant class name.
rb_intern("Message"),
rb_cObject);
rb_ivar_set(klass, descriptor_instancevar_interned,
get_def_obj(desc->msgdef));
rb_define_alloc_func(klass, Message_alloc);
rb_require("google/protobuf/message_exts");
rb_include_module(klass, rb_eval_string("::Google::Protobuf::MessageExts"));
rb_extend_object(
klass, rb_eval_string("::Google::Protobuf::MessageExts::ClassMethods"));
rb_define_method(klass, "method_missing",
Message_method_missing, -1);
rb_define_method(klass, "respond_to_missing?",
Message_respond_to_missing, -1);
rb_define_method(klass, "initialize", Message_initialize, -1);
rb_define_method(klass, "dup", Message_dup, 0);
// Also define #clone so that we don't inherit Object#clone.
rb_define_method(klass, "clone", Message_dup, 0);
rb_define_method(klass, "==", Message_eq, 1);
rb_define_method(klass, "hash", Message_hash, 0);
rb_define_method(klass, "to_h", Message_to_h, 0);
rb_define_method(klass, "to_hash", Message_to_h, 0);
rb_define_method(klass, "inspect", Message_inspect, 0);
rb_define_method(klass, "[]", Message_index, 1);
rb_define_method(klass, "[]=", Message_index_set, 2);
rb_define_singleton_method(klass, "decode", Message_decode, 1);
rb_define_singleton_method(klass, "encode", Message_encode, 1);
rb_define_singleton_method(klass, "decode_json", Message_decode_json, -1);
rb_define_singleton_method(klass, "encode_json", Message_encode_json, -1);
rb_define_singleton_method(klass, "descriptor", Message_descriptor, 0);
return klass;
}
/**
* TBD
*
* @param argc TBD
* @param argv TBD
* @return TBD
*/
int main( int argc, char *argv[] ) {
// Initialize the GTK library
gtk_init( &argc, &argv );
if ( !load_config( ) )
scan_fonts( );
create_layout( );
init_new_game( TRUE, TRUE );
gtk_main( );
return ( 0 );
} // main
Main_GUI::Main_GUI(int range_min,
int range_max,
int limit,
bool gray,
bool gdi,
bool dw,
int increase,
const char* exceptions,
bool ignore,
bool wincomp,
bool pre,
bool components,
bool no,
int fallback,
bool symb)
: hinting_range_min(range_min),
hinting_range_max(range_max),
hinting_limit(limit),
gray_strong_stem_width(gray),
gdi_cleartype_strong_stem_width(gdi),
dw_cleartype_strong_stem_width(dw),
increase_x_height(increase),
x_height_snapping_exceptions_string(exceptions),
ignore_restrictions(ignore),
windows_compatibility(wincomp),
pre_hinting(pre),
hint_with_components(components),
no_info(no),
latin_fallback(fallback),
symbol(symb)
{
x_height_snapping_exceptions = NULL;
create_layout();
create_connections();
create_actions();
create_menus();
create_status_bar();
set_defaults();
read_settings();
setUnifiedTitleAndToolBarOnMac(true);
// XXX register translations somewhere and loop over them
if (QLocale::system().name() == "en_US")
locale = new QLocale;
else
locale = new QLocale(QLocale::C);
}
static void add_handlers_for_message(const void *closure, upb_handlers *h) {
const upb_msgdef* msgdef = upb_handlers_msgdef(h);
Descriptor* desc = ruby_to_Descriptor(get_def_obj((void*)msgdef));
upb_msg_field_iter i;
// If this is a mapentry message type, set up a special set of handlers and
// bail out of the normal (user-defined) message type handling.
if (upb_msgdef_mapentry(msgdef)) {
add_handlers_for_mapentry(msgdef, h, desc);
return;
}
// Ensure layout exists. We may be invoked to create handlers for a given
// message if we are included as a submsg of another message type before our
// class is actually built, so to work around this, we just create the layout
// (and handlers, in the class-building function) on-demand.
if (desc->layout == NULL) {
desc->layout = create_layout(desc->msgdef);
}
for (upb_msg_field_begin(&i, desc->msgdef);
!upb_msg_field_done(&i);
upb_msg_field_next(&i)) {
const upb_fielddef *f = upb_msg_iter_field(&i);
size_t offset = desc->layout->fields[upb_fielddef_index(f)].offset +
sizeof(MessageHeader);
if (upb_fielddef_containingoneof(f)) {
size_t oneof_case_offset =
desc->layout->fields[upb_fielddef_index(f)].case_offset +
sizeof(MessageHeader);
add_handlers_for_oneof_field(h, f, offset, oneof_case_offset);
} else if (is_map_field(f)) {
add_handlers_for_mapfield(h, f, offset, desc);
} else if (upb_fielddef_isseq(f)) {
add_handlers_for_repeated_field(h, f, offset);
} else {
add_handlers_for_singular_field(h, f, offset);
}
}
}
static void
gutter_renderer_text_begin (GtkSourceGutterRenderer *renderer,
cairo_t *cr,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GtkTextIter *start,
GtkTextIter *end)
{
GtkSourceGutterRendererText *text = GTK_SOURCE_GUTTER_RENDERER_TEXT (renderer);
create_layout (text, GTK_WIDGET (gtk_source_gutter_renderer_get_view (renderer)));
if (GTK_SOURCE_GUTTER_RENDERER_CLASS (gtk_source_gutter_renderer_text_parent_class)->begin != NULL)
{
GTK_SOURCE_GUTTER_RENDERER_CLASS (gtk_source_gutter_renderer_text_parent_class)->begin (renderer,
cr,
background_area,
cell_area,
start,
end);
}
}
static gpointer
thread_func (gpointer data)
{
cairo_surface_t *surface = data;
PangoLayout *layout;
int i;
cairo_t *cr = cairo_create (surface);
layout = create_layout (cr);
g_mutex_lock (&mutex);
g_mutex_unlock (&mutex);
for (i = 0; i < num_iters; i++)
draw (cr, layout, i);
g_object_unref (layout);
cairo_destroy (cr);
return 0;
}
int
main (int argc, char **argv)
{
int num_threads = 10;
int i;
GPtrArray *threads = g_ptr_array_new ();
GPtrArray *surfaces = g_ptr_array_new ();
if (argc > 1)
num_threads = atoi (argv[1]);
if (argc > 2)
num_iters = atoi (argv[2]);
#if !GLIB_CHECK_VERSION (2, 35, 3)
g_type_init();
#endif
g_mutex_lock (&mutex);
for (i = 0; i < num_threads; i++)
{
char buf[10];
cairo_surface_t *surface = create_surface ();
g_ptr_array_add (surfaces, surface);
g_snprintf (buf, sizeof (buf), "%d", i);
g_ptr_array_add (threads,
g_thread_new (buf,
thread_func,
surface));
}
/* Let them loose! */
g_mutex_unlock (&mutex);
for (i = 0; i < num_threads; i++)
g_thread_join (g_ptr_array_index (threads, i));
g_ptr_array_free (threads, TRUE);
/* Now, draw a reference image and check results. */
{
cairo_surface_t *ref_surface = create_surface ();
cairo_t *cr = cairo_create (ref_surface);
PangoLayout *layout = create_layout (cr);
unsigned char *ref_data = cairo_image_surface_get_data (ref_surface);
unsigned int len = WIDTH * HEIGHT;
draw (cr, layout, num_iters - 1);
g_object_unref (layout);
cairo_destroy (cr);
/* cairo_surface_write_to_png (ref_surface, "test-pangocairo-threads-reference.png"); */
g_assert (WIDTH == cairo_format_stride_for_width (CAIRO_FORMAT_A8, WIDTH));
for (i = 0; i < num_threads; i++)
{
cairo_surface_t *surface = g_ptr_array_index (surfaces, i);
unsigned char *data = cairo_image_surface_get_data (surface);
if (memcmp (ref_data, data, len))
{
fprintf (stderr, "image for thread %d different from reference image.\n", i);
cairo_surface_write_to_png (ref_surface, "test-pangocairo-threads-reference.png");
cairo_surface_write_to_png (surface, "test-pangocairo-threads-failed.png");
return 1;
}
cairo_surface_destroy (surface);
}
cairo_surface_destroy (ref_surface);
}
g_ptr_array_free (surfaces, TRUE);
pango_cairo_font_map_set_default (NULL);
return 0;
}
static GtkWidget *
create_widgets (void)
{
GtkWidget *main_hbox, *main_vbox;
GtkWidget *vbox, *hbox, *label, *combo, *entry, *button, *cb;
GtkWidget *sw, *text_view;
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), main_hbox, TRUE, TRUE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (main_hbox), vbox, TRUE, TRUE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new ("This label may be ellipsized\nto make it fit.");
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "NONE");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "START");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "MIDDLE");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "END");
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0);
g_signal_connect (combo, "changed",
G_CALLBACK (combo_changed_cb),
label);
entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry), "an entry - lots of text.... lots of text.... lots of text.... lots of text.... ");
gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
label = gtk_label_new ("Label after entry.");
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Button");
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
button = gtk_check_button_new_with_mnemonic ("_Check button");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
cb = gtk_combo_box_text_new ();
entry = gtk_entry_new ();
gtk_widget_show (entry);
gtk_container_add (GTK_CONTAINER (cb), entry);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (cb), "item0");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (cb), "item1");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (cb), "item1");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (cb), "item2");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (cb), "item2");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (cb), "item2");
gtk_entry_set_text (GTK_ENTRY (entry), "hello world ♥ foo");
gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1);
gtk_box_pack_start (GTK_BOX (vbox), cb, TRUE, TRUE, 0);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
text_view = gtk_text_view_new ();
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (sw), text_view);
create_layout (vbox);
create_treeview (main_hbox);
return main_vbox;
}
static void
hippo_canvas_text_paint_below_children(HippoCanvasBox *box,
cairo_t *cr,
GdkRegion *damaged_region)
{
HippoCanvasText *text = HIPPO_CANVAS_TEXT(box);
guint32 color_rgba;
if (box->color_set) {
color_rgba = box->color_rgba;
} else {
HippoCanvasStyle *style = hippo_canvas_context_get_style(HIPPO_CANVAS_CONTEXT(text));
color_rgba = hippo_canvas_style_get_foreground_color(style);
}
/* It would seem more natural to compute whether we are ellipsized or
* not when we are allocated to some width, but we don't have a layout
* at that point. We could do it in get_content_height_request(), but
* the parent could theoretically give us more width than it asked us
* about (and there are also some quirks in HippoCanvasBox where it
* will call get_content_height_request() with a width if 0 at odd times),
* so doing it here is more reliable. We use is_ellipsized only for
* computing whether to show a tooltip, and we make the assumption that
* if the user hasn't seen the text item drawn, they won't need a
* tooltip for it.
*/
text->is_ellipsized = FALSE;
if ((color_rgba & 0xff) != 0 && text->text != NULL) {
PangoLayout *layout;
int layout_width, layout_height;
int x, y, w, h;
int allocation_width, allocation_height;
int space_left = box->border_left + box->padding_left;
int space_right = box->border_right + box->padding_right;
hippo_canvas_item_get_allocation(HIPPO_CANVAS_ITEM(box),
&allocation_width, &allocation_height);
layout = create_layout(text, allocation_width - space_left - space_right);
pango_layout_get_size(layout, &layout_width, &layout_height);
layout_width /= PANGO_SCALE;
layout_height /= PANGO_SCALE;
text->is_ellipsized = layout_is_ellipsized(layout);
hippo_canvas_box_align(box,
layout_width, layout_height,
&x, &y, &w, &h);
/* we can't really "fill" so we fall back to center if we seem to be
* in fill mode
*/
if (w > layout_width) {
x += (w - layout_width) / 2;
}
if (h > layout_height) {
y += (h - layout_height) / 2;
}
/* Clipping is needed since the layout size could exceed our
* allocation if we got a too-small allocation.
* FIXME It would be better to ellipsize or something instead, though.
*/
cairo_save(cr);
cairo_rectangle(cr, 0, 0, allocation_width, allocation_height);
cairo_clip(cr);
cairo_move_to (cr, x, y);
hippo_cairo_set_source_rgba32(cr, color_rgba);
pango_cairo_show_layout(cr, layout);
cairo_restore(cr);
g_object_unref(layout);
}
}
