static GWENHYWFAR_CB int Gtk3Gui_WGroupBox_SetCharProperty(GWEN_WIDGET *w, GWEN_DIALOG_PROPERTY prop, int index, const char *value, int doSignal) { GtkWidget *g; g=GTK_WIDGET(GWEN_Widget_GetImplData(w, GTK3_DIALOG_WIDGET_REAL)); assert(g); switch (prop) { case GWEN_DialogProperty_Title: gtk_frame_set_label(GTK_FRAME(g), value); return 0; default: break; } DBG_WARN(GWEN_LOGDOMAIN, "Function is not appropriate for this type of widget (%s)", GWEN_Widget_Type_toString(GWEN_Widget_GetType(w))); return GWEN_ERROR_INVALID; }
void wxStaticBox::SetLabel( const wxString &label ) { wxControl::SetLabel( label ); gtk_frame_set_label( GTK_FRAME( m_widget ), m_label.empty() ? (char *)NULL : (const char*) wxGTK_CONV( m_label ) ); }
/* Reset the statistics window */ static void rlc_lte_stat_reset(void *phs) { rlc_lte_stat_t* rlc_lte_stat = (rlc_lte_stat_t *)phs; rlc_lte_ep_t* list = rlc_lte_stat->ep_list; gchar title[256]; GtkListStore *store; /* Set the title */ if (rlc_lte_stat->dlg_w != NULL) { g_snprintf(title, sizeof(title), "Wireshark: LTE RLC Traffic Statistics: %s (filter=\"%s\")", cf_get_display_name(&cfile), rlc_lte_stat->filter ? rlc_lte_stat->filter : "none"); gtk_window_set_title(GTK_WINDOW(rlc_lte_stat->dlg_w), title); } g_snprintf(title, sizeof(title), "0 UEs"); gtk_frame_set_label(GTK_FRAME(rlc_lte_stat->ues_lb), title); rlc_lte_stat->total_frames = 0; memset(&rlc_lte_stat->common_stats, 0, sizeof(rlc_lte_common_stats)); /* Remove all entries from the UE list */ store = GTK_LIST_STORE(gtk_tree_view_get_model(rlc_lte_stat->ue_table)); gtk_list_store_clear(store); if (!list) { return; } rlc_lte_stat->ep_list = NULL; }
void gFrame::setText(const char *vl) { if (!vl) vl = ""; gtk_frame_set_label(GTK_FRAME(fr), vl); /*bool remove = false; remove = !vl || !*vl; if (remove) { if (label) { gtk_frame_set_label_widget(GTK_FRAME(fr), NULL); label = NULL; } return; } if (!label) { label = gtk_label_new(vl); gtk_frame_set_label_widget(GTK_FRAME(fr), label); updateFont(); setForeground(foreground()); gtk_widget_show(label); } else gtk_label_set_text(GTK_LABEL(label), (const gchar*)vl);*/ }
void wxRadioBox::SetLabel( const wxString& label ) { wxCHECK_RET( m_widget != NULL, wxT("invalid radiobox") ); wxControl::SetLabel( label ); gtk_frame_set_label( GTK_FRAME(m_widget), wxGTK_CONV( wxControl::GetLabel() ) ); }
static void wlanstat_reset (void *phs) { wlanstat_t* wlan_stat = (wlanstat_t *)phs; wlan_ep_t* list = wlan_stat->ep_list; wlan_ep_t* tmp = NULL; char title[256]; GString *error_string; GtkListStore *store; const char *filter = NULL; if (wlanstat_dlg_w != NULL) { g_snprintf (title, sizeof(title), "Wireshark: WLAN Traffic Statistics: %s", cf_get_display_name(&cfile)); gtk_window_set_title(GTK_WINDOW(wlanstat_dlg_w), title); } if (wlan_stat->use_dfilter) { filter = gtk_entry_get_text(GTK_ENTRY(main_display_filter_widget)); } error_string = set_tap_dfilter (wlan_stat, filter); if (error_string) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str); g_string_free(error_string, TRUE); return; } if (wlan_stat->use_dfilter) { if (filter && strlen(filter)) { g_snprintf(title, sizeof(title), "Network Overview - Filter: %s", filter); } else { g_snprintf(title, sizeof(title), "Network Overview - No Filter"); } } else { g_snprintf(title, sizeof(title), "Network Overview"); } gtk_frame_set_label(GTK_FRAME(wlanstat_name_lb), title); /* remove all entries from the list */ store = GTK_LIST_STORE(gtk_tree_view_get_model(wlan_stat->table)); gtk_list_store_clear(store); store = GTK_LIST_STORE(gtk_tree_view_get_model(wlan_stat->details)); gtk_list_store_clear(store); if (!list) return; while (list) { tmp = list; dealloc_wlan_details_ep (tmp->details); list = tmp->next; g_free (tmp); } wlan_stat->ep_list = NULL; wlan_stat->number_of_packets = 0; }
static int gtkFrameSetTitleAttrib(Ihandle* ih, const char* value) { if (iupAttribGetStr(ih, "_IUPFRAME_HAS_TITLE")) { GtkFrame* frame = (GtkFrame*)ih->handle; gtk_frame_set_label(frame, iupgtkStrConvertToUTF8(value)); } return 0; }
void size_callb (gpointer data,GtkWidget *wdg) { // Sets size when creating a new HF gint hf_size; static gchar area_label[12]; omenu_struct_type *opt_menu; hf_wrapper_struct *hfw; hf_options_struct *hfo; opt_menu = (omenu_struct_type *) data; // printf("DATA in SIZE_CALLB: %d;\n",data); hfo = (hf_options_struct *) opt_menu->data; // printf("HFO in SIZE_CALLB: %d;\n",hfo); if (!hfo) return; hfw = (hf_wrapper_struct *) * (hf_wrapper_struct **) hfo->hfw_ptr_ptr; hf_size = opt_menu->list[opt_menu->current_index].num; if (!hfw) return; if (!hfw->hf_struct) return; if (hf_size == hfw->hf_struct->max_x) // No change! return; sprintf(area_label, "%d x %d", hf_size, hf_size); gtk_frame_set_label(GTK_FRAME(hfw->draw_area_frame), area_label); hf_free(hfw->hf_struct); hfw->hf_options->hf_size = hf_size; hfw->hf_struct = (hf_struct_type *) hf_new(hf_size); hfw->display_scale = get_display_scale(hf_size); hfw->hf_buf8 = (unsigned char *) x_malloc((RIGHT_SHIFT(hf_size, hfw->display_scale)) * (RIGHT_SHIFT(hf_size,hfw->display_scale))*sizeof(unsigned char), "unsigned char (hfw->buf8 in size_callb)"); hfw->if_rgb = FALSE; hfw->area_size = RIGHT_SHIFT(hf_size,hfw->display_scale); set_current_button (hfw->sbs, hfw->display_scale); hfw->size_change_request = TRUE; gtk_widget_set_size_request (hfw->draw_area_frame, hfw->area_size+SCALE_PAD, hfw->area_size+SCALE_PAD); // printf("SIZE_CALLB: HFW: %d; HF_SIZE: %d; DISPLAY_SCALE: %d; AREA_SIZE: %d\n", hfw, hf_size, hfw->display_scale, hfw->area_size); init_render_struct(hfw->hf_options->render_str, hfw->dirname, hfw->filename, &hfw->creation_mode, hfw->if_modified, hfw->gl_preview, hfw->hf_struct->hf_buf, hfw->hf_struct->max_x, hfw->hf_struct->max_y); gl_set_input_grid (hfw->gl_preview, hfw->hf_struct->hf_buf, hfw->hf_struct->max_x, hfw->hf_struct->max_y, HF_TYPE_ID); gl_update_details_display (hfw->gl_preview); gtk_drawing_area_size(GTK_DRAWING_AREA(hfw->area), hfw->area_size, hfw->area_size); }
void wxControl::GTKSetLabelForFrame(GtkFrame *w, const wxString& label) { wxControl::SetLabel(label); const wxString labelGTK = GTKRemoveMnemonics(label); gtk_frame_set_label(w, labelGTK.empty() ? (const char *)NULL : wxGTK_CONV(labelGTK)); }
static void kovaplusconfig_sensitivity_frame_init(KovaplusconfigSensitivityFrame *frame) { frame->priv = KOVAPLUSCONFIG_SENSITIVITY_FRAME_GET_PRIVATE(frame); frame->priv->scale = GAMINGGEAR_XY_SCALES(gaminggear_xy_scales_new( (gdouble)KOVAPLUS_SENSITIVITY_MIN, (gdouble)KOVAPLUS_SENSITIVITY_MAX, (gdouble)1.0)); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(frame->priv->scale)); gtk_frame_set_label(GTK_FRAME(frame), _("Sensitivity")); }
static void SetFrame( GtkWidget *widget, WidgetData *wdata, _Frame *data) { ENTER_FUNC; SetCommon(widget,wdata); gtk_frame_set_label(GTK_FRAME(widget),data->label); LEAVE_FUNC; }
/** * facq_display_set_title: * @dis: A #FacqDisplay object. * @title: A string with the text for the title. * * Sets the text in the label of the toplevel #GtkFrame. */ void facq_display_set_title(FacqDisplay *dis,const gchar *title) { g_return_if_fail(FACQ_IS_DISPLAY(dis)); g_return_if_fail(title); if(dis->priv->title) g_free(dis->priv->title); dis->priv->title = g_strdup(title); gtk_frame_set_label(GTK_FRAME(dis->priv->frame),dis->priv->title); }
int main (int argc, char **argv) { GtkWidget *window, *vbox, *frame, *swtch, *swtch2, *toggle, *vbox2; gboolean is_active = FALSE; gtk_init (&argc, &argv); if (argc > 1) is_active = atoi (argv[1]); g_debug ("setting switch to '%d'", is_active); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (window), 320, 240); vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 10); gtk_container_add (GTK_CONTAINER (window), vbox); frame = mx_gtk_frame_new (); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 10); gtk_frame_set_label (GTK_FRAME (frame), "Frame Title"); vbox2 = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox2), 10); gtk_container_add (GTK_CONTAINER (frame), vbox2); swtch = mx_gtk_light_switch_new (); mx_gtk_light_switch_set_active (MX_GTK_LIGHT_SWITCH (swtch), is_active); gtk_container_add (GTK_CONTAINER (vbox2), swtch); swtch2 = mx_gtk_light_switch_new (); gtk_widget_set_sensitive (swtch2, FALSE); mx_gtk_light_switch_set_active (MX_GTK_LIGHT_SWITCH (swtch2), is_active); gtk_container_add (GTK_CONTAINER (vbox2), swtch2); frame = gtk_alignment_new (0, 0, 0, 0); gtk_alignment_set_padding (GTK_ALIGNMENT (frame), 10, 10, 10, 10); gtk_container_add (GTK_CONTAINER (vbox), frame); toggle = gtk_toggle_button_new_with_label ("Toggle"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), is_active); gtk_container_add (GTK_CONTAINER (frame), toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (_toggle_cb), swtch); gtk_widget_show_all (window); g_signal_connect (window, "delete-event", gtk_main_quit, NULL); gtk_main (); return 0; }
void ghack_menu_window_end_menu (GtkWidget *menuWin, gpointer data) { const char* p = (const char*) data; if ((p) && (*p)) { GtkWidget *frame1 = gtk_object_get_data (GTK_OBJECT (menuWin), "frame1"); g_assert (frame1 != NULL); gtk_frame_set_label (GTK_FRAME(frame1), p); } }
static void callback_frame_thumbnail_press (GtkWidget * event_box, GdkEventButton * event, gpointer user_data) { GtkWidget *label; gchar *file_name; gchar *name; gchar *frame_name_markup; gint frame_num; frame_num = (gint) user_data; name = g_strdup_printf ("%s-%d.xml", ui->codec_name, frame_num); file_name = g_build_filename (ui->analyzer_home, "xml", name, NULL); if (ui->current_xml) g_free (ui->current_xml); g_free (name); ui->current_xml = file_name; name = g_strdup_printf ("%s-%d.hex", ui->codec_name, frame_num); file_name = g_build_filename (ui->analyzer_home, "hex", name, NULL); if (ui->current_hex) g_free (ui->current_hex); g_free (name); ui->current_hex = file_name; g_signal_connect (G_OBJECT (ui->header_button), "button-press-event", G_CALLBACK (callback_button_box_click), (gpointer) COMPONENTS_HEADERS_GENERAL); g_signal_connect (G_OBJECT (ui->slice_button), "button-press-event", G_CALLBACK (callback_button_box_click), (gpointer) COMPONENTS_HEADERS_SLICE); g_signal_connect (G_OBJECT (ui->hexval_button), "button-press-event", G_CALLBACK (callback_button_box_click), (gpointer) COMPONENTS_HEXVAL); /* load general headers by default */ callback_button_box_click (NULL, NULL, (gpointer) COMPONENTS_HEADERS_GENERAL); /*update the label of parsed_info_frame with frame_number */ gtk_frame_set_label (GTK_FRAME (ui->parsed_info_frame), ""); label = gtk_frame_get_label_widget (GTK_FRAME (ui->parsed_info_frame)); frame_name_markup = g_markup_printf_escaped ("<span style=\"italic\" size=\"xx-large\">Frame %d</span>", frame_num + 1); gtk_label_set_markup (GTK_LABEL (label), frame_name_markup); g_free (frame_name_markup); gtk_widget_show_all (ui->main_window); }
static void reset_analyzer_ui (void) { if (ui->hbox1_in_vbox2) { gtk_widget_destroy (GTK_WIDGET (ui->hbox1_in_vbox2)); ui->hbox1_in_vbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); g_object_set (G_OBJECT (ui->hbox1_in_vbox2), "visible", TRUE, "can-focus", FALSE, NULL); gtk_container_add (GTK_CONTAINER (ui->thumbnails_view_port), ui->hbox1_in_vbox2); } if (ui->general_info_treeview) { gtk_widget_destroy (GTK_WIDGET (ui->general_info_treeview)); ui->general_info_treeview = gtk_tree_view_new (); gtk_box_pack_end (GTK_BOX (ui->general_info_vbox), ui->general_info_treeview, TRUE, TRUE, 0); } if (ui->parsed_info_button_box) { gtk_widget_destroy (GTK_WIDGET (ui->parsed_info_button_box)); ui->parsed_info_button_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); g_object_set (G_OBJECT (ui->parsed_info_button_box), "visible", TRUE, "can-focus", TRUE, NULL); gtk_box_pack_start (GTK_BOX (ui->parsed_info_hbox), ui->parsed_info_button_box, FALSE, FALSE, 0); } if (ui->parsed_info_vbox) { gtk_widget_destroy (GTK_WIDGET (ui->parsed_info_vbox)); ui->parsed_info_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); g_object_set (G_OBJECT (ui->parsed_info_vbox), "visible", TRUE, "can-focus", TRUE, NULL); gtk_box_pack_start (GTK_BOX (ui->parsed_info_hbox), ui->parsed_info_vbox, TRUE, TRUE, 0); } if (ui->parsed_info_frame) gtk_frame_set_label (GTK_FRAME (ui->parsed_info_frame), ""); if (ui->notebook_hash) g_hash_table_destroy (ui->notebook_hash); ui->notebook_hash = g_hash_table_new (g_str_hash, g_str_equal); ui->prev_page = NULL; gtk_widget_show_all (ui->main_window); }
static void konepuremilitary_sensor_alignment_frame_init(KonepuremilitarySensorAlignmentFrame *frame) { KonepuremilitarySensorAlignmentFramePrivate *priv = KONEPUREMILITARY_SENSOR_ALIGNMENT_FRAME_GET_PRIVATE(frame); GtkWidget *hbox; frame->priv = priv; hbox = gtk_hbox_new(FALSE, 0); priv->scale = scale_new(); priv->flag = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("Active"))); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(priv->flag), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(priv->scale), TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(frame), hbox); gtk_frame_set_label(GTK_FRAME(frame), _("Sensor alignment")); }
static void konepuremilitary_anglesnap_frame_init(KonepuremilitaryAnglesnapFrame *frame) { KonepuremilitaryAnglesnapFramePrivate *priv = KONEPUREMILITARY_ANGLESNAP_FRAME_GET_PRIVATE(frame); GtkWidget *hbox; frame->priv = priv; hbox = gtk_hbox_new(FALSE, 0); priv->scale = scale_new(); priv->flag = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(_("Active"))); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(priv->flag), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(priv->scale), TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(frame), hbox); gtk_frame_set_label(GTK_FRAME(frame), _("Angle snapping")); }
int main( int argc, char *argv[] ) { /* GtkWidget is the storage type for widgets */ GtkWidget *window; GtkWidget *frame; GtkWidget *button; gint i; /* Initialise GTK */ gtk_init(&argc, &argv); /* Create a new window */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "Frame Example"); /* Here we connect the "destroy" event to a signal handler */ gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (gtk_main_quit), NULL); gtk_widget_set_usize(window, 300, 300); /* Sets the border width of the window. */ gtk_container_set_border_width (GTK_CONTAINER (window), 10); /* Create a Frame */ frame = gtk_frame_new(NULL); gtk_container_add(GTK_CONTAINER(window), frame); /* Set the frame's label */ gtk_frame_set_label( GTK_FRAME(frame), "GTK Frame Widget" ); /* Align the label at the right of the frame */ gtk_frame_set_label_align( GTK_FRAME(frame), 1.0, 0.0); /* Set the style of the frame */ gtk_frame_set_shadow_type( GTK_FRAME(frame), GTK_SHADOW_ETCHED_OUT); gtk_widget_show(frame); /* Display the window */ gtk_widget_show (window); /* Enter the event loop */ gtk_main (); return(0); }
static void roccat_handedness_selector_init(RoccatHandednessSelector *selector) { RoccatHandednessSelectorPrivate *priv = ROCCAT_HANDEDNESS_SELECTOR_GET_PRIVATE(selector); GtkWidget *hbox; selector->priv = priv; hbox = gtk_hbox_new(TRUE, 0); gtk_container_add(GTK_CONTAINER(selector), hbox); priv->left = GTK_RADIO_BUTTON(gtk_radio_button_new_with_label(NULL, _("Left handed"))); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(priv->left), TRUE, TRUE, 0); priv->right = GTK_RADIO_BUTTON(gtk_radio_button_new_with_label_from_widget(priv->left, _("Right handed"))); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(priv->right), TRUE, TRUE, 0); gtk_frame_set_label(GTK_FRAME(selector), _("Handedness")); }
/* control frequency */ static void on_freq_changed (GtkRange * range, gpointer user_data) { GstObject *band = GST_OBJECT (user_data); gdouble value = gtk_range_get_value (range); /* hbox */ GtkWidget *parent = gtk_widget_get_parent (GTK_WIDGET (range)); /* frame */ GtkWidget *parent_parent = gtk_widget_get_parent (parent); gchar *label = g_strdup_printf ("%d Hz", (int) (value + 0.5)); gtk_frame_set_label (GTK_FRAME (parent_parent), label); g_free (label); g_object_set (band, "freq", value, NULL); }
static void nyth_light_effects_frame_init(NythLightEffectsFrame *frame) { NythLightEffectsFramePrivate *priv = NYTH_LIGHT_EFFECTS_FRAME_GET_PRIVATE(frame); GtkBox *box; frame->priv = priv; box = GTK_BOX(gtk_vbox_new(FALSE, 0)); add_radios_color_effect(box, frame); gtk_box_pack_start(box, gtk_hseparator_new(), TRUE, TRUE, 0); add_radios_light_effect(box, frame); gtk_box_pack_start(box, gtk_hseparator_new(), TRUE, TRUE, 0); add_speed(box, frame); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box)); gtk_frame_set_label(GTK_FRAME(frame), _("Light effects")); }
void usb_register( void ) { FILE *pd; gtk_frame_set_label( GTK_FRAME( body_frame), "Installation step - 3/5 (register a usb device)" ); status_label = gtk_label_new("..."); gtk_table_attach_defaults ( GTK_TABLE (main_table), status_label, 1, 11, 1, 9); gtk_widget_show( status_label ); gtk_label_set_text( GTK_LABEL( status_label), "Insert the USB device. ( it will be used to unlock the system )\n\n\nIf the desired USB device is already inserted then simply remove it to register." ); pd = popen( "lsusb | wc -l", "r" ); system( "lsusb > old_data" ); fscanf( pd, "%d", &old_lscount ); pclose( pd ); gtk_timeout_add( 1000, register_new_usb, NULL ); }
void start_final_installation( void ) { gtk_frame_set_label( GTK_FRAME( body_frame), "Installation step - 5/5 ( managing source files )" ); gtk_button_set_label( GTK_BUTTON( cancel_button), "Finish" ); gtk_widget_set_sensitive( GTK_WIDGET( cancel_button), FALSE ); pattern_label = gtk_label_new( "" ); gtk_container_add( GTK_CONTAINER( body_frame), pattern_label ); gtk_widget_show_all( main_window ); fd = popen( "whoami", "r" ); fscanf( fd, "%s", system_user_name ); pclose(fd); create_directories(); create_files(); manage_files(); }
int ags_machine_popup_rename_response_callback(GtkWidget *widget, gint response, AgsMachine *machine) { gchar *text; if(response == GTK_RESPONSE_ACCEPT){ if(machine->name != NULL) free(machine->name); text = gtk_editable_get_chars(GTK_EDITABLE(gtk_container_get_children((GtkContainer *) GTK_DIALOG(widget)->vbox)->data), 0, -1); machine->name = text; gtk_frame_set_label((GtkFrame *) gtk_container_get_children((GtkContainer *) machine)->data, g_strconcat(G_OBJECT_TYPE_NAME(machine), ": \0", text, NULL)); g_free(text); } gtk_widget_destroy(widget); return(0); }
static void ryosconfig_illumination_frame_init(RyosconfigIlluminationFrame *illumination_frame) { RyosconfigIlluminationFramePrivate *priv = RYOSCONFIG_ILLUMINATION_FRAME_GET_PRIVATE(illumination_frame); illumination_frame->priv = priv; GtkBox *hbox; GtkButton *layer_illumination_button; priv->pointer = NULL; hbox = GTK_BOX(gtk_hbox_new(FALSE, 0)); layer_illumination_button = GTK_BUTTON(gtk_button_new_with_label(_("Editor"))); priv->multiwidget = ROCCAT_MULTIWIDGET(roccat_multiwidget_new()); priv->table = GTK_TABLE(gtk_table_new(3, 2, FALSE)); priv->nothing = GTK_LABEL(gtk_label_new(_("This model does not support illumination settings"))); priv->mode = RYOS_LAYER_MODE_SELECTOR(ryos_layer_mode_selector_new()); priv->layer = RYOS_LAYER_SELECTOR(ryos_layer_selector_new()); priv->effect = RYOSCONFIG_EFFECT_SELECTOR(ryosconfig_effect_selector_new()); gtk_label_set_line_wrap(GTK_LABEL(priv->nothing), TRUE); g_signal_connect(G_OBJECT(layer_illumination_button), "clicked", G_CALLBACK(layer_illumination_dialog_cb), illumination_frame); priv->mode_changed_handler_id = g_signal_connect(G_OBJECT(priv->mode), "changed", G_CALLBACK(mode_changed_cb), illumination_frame); priv->layer_changed_handler_id = g_signal_connect(G_OBJECT(priv->layer), "changed", G_CALLBACK(layer_changed_cb), illumination_frame); priv->effect_changed_handler_id = g_signal_connect(G_OBJECT(priv->effect), "changed", G_CALLBACK(effect_changed_cb), illumination_frame); gtk_box_pack_start(hbox, GTK_WIDGET(priv->layer), TRUE, TRUE, 0); gtk_box_pack_start(hbox, GTK_WIDGET(layer_illumination_button), FALSE, FALSE, 0); gtk_table_attach(priv->table, gtk_label_new(_("Mode")), 0, 1, 0, 1, 0, GTK_EXPAND, 0, 0); gtk_table_attach(priv->table, GTK_WIDGET(priv->mode), 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND, 0, 0); gtk_table_attach(priv->table, gtk_label_new(_("Layer")), 0, 1, 1, 2, 0, GTK_EXPAND, 0, 0); gtk_table_attach(priv->table, GTK_WIDGET(hbox), 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND, 0, 0); gtk_table_attach(priv->table, gtk_label_new(_("Effect")), 0, 1, 2, 3, 0, GTK_EXPAND, 0, 0); gtk_table_attach(priv->table, GTK_WIDGET(priv->effect), 1, 2, 2, 3, GTK_EXPAND | GTK_FILL, GTK_EXPAND, 0, 0); roccat_multiwidget_add(priv->multiwidget, GTK_WIDGET(priv->table)); roccat_multiwidget_add(priv->multiwidget, GTK_WIDGET(priv->nothing)); gtk_container_add(GTK_CONTAINER(illumination_frame), GTK_WIDGET(priv->multiwidget)); gtk_frame_set_label(GTK_FRAME(illumination_frame), _("Illumination")); }
static void nyth_dcu_frame_init(NythDcuFrame *frame) { NythDcuFramePrivate *priv = NYTH_DCU_FRAME_GET_PRIVATE(frame); GtkWidget *box; GtkWidget *radio; int i; frame->priv = priv; box = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), box); struct { NythControlUnitDcu state; gchar const *title; } radios[4] = { {NYTH_DISTANCE_CONTROL_UNIT_OFF, N_("Off")}, {NYTH_DISTANCE_CONTROL_UNIT_EXTRA_LOW, N_("Extra low")}, {NYTH_DISTANCE_CONTROL_UNIT_LOW, N_("Low")}, {NYTH_DISTANCE_CONTROL_UNIT_NORMAL, N_("Normal")}, }; priv->radios = NULL; for (i = 3; i >= 0; --i) { radio = gtk_radio_button_new_with_label(priv->radios, _N(radios[i].title)); g_object_set_data(G_OBJECT(radio), state_key, GUINT_TO_POINTER(radios[i].state)); priv->radios = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio)); g_signal_connect(G_OBJECT(radio), "toggled", G_CALLBACK(radio_toggled_cb), frame); } g_slist_foreach(priv->radios, pack_radio_button, box); gtk_frame_set_label(GTK_FRAME(frame), _("Distance control unit")); gtk_widget_show_all(box); }
static void refreshFrames(void) { struct viewport *pp = NULL; GList *it = ports; int mypage_i; gchar *title = NULL; while (it) { pp = (struct viewport *)(it->data); /* the beamer has no frame */ if (pp->isBeamer == FALSE) { /* reset background color */ gtk_widget_modify_bg(pp->frame->parent, GTK_STATE_NORMAL, NULL); /* lock mode: highlight the saved/current page */ if (beamer_active == FALSE) { if (doc_page + pp->offset == doc_page_mark) { gtk_widget_modify_bg(pp->frame->parent, GTK_STATE_NORMAL, &col_marked); } else if (pp->offset == 0) { gtk_widget_modify_bg(pp->frame->parent, GTK_STATE_NORMAL, &col_dim); } } /* normal mode: highlight the "current" frame */ else { if (pp->offset == 0) { gtk_widget_modify_bg(pp->frame->parent, GTK_STATE_NORMAL, &col_current); } } /* Refresh labels. */ if (pp->frame != NULL) { mypage_i = pagenumForPort(pp); if (mypage_i < 0 || mypage_i >= doc_n_pages) { gtk_frame_set_label(GTK_FRAME(pp->frame), "X"); } else { title = g_strdup_printf("Slide %d / %d", mypage_i + 1, doc_n_pages); gtk_frame_set_label(GTK_FRAME(pp->frame), title); g_free(title); } } } it = g_list_next(it); } }
static gboolean onCanvasDraw(GtkWidget *widget, cairo_t *cr, struct viewport *pp) { (void)widget; int mypage_i, myfitmode = -1; gdouble w = 0, h = 0; gchar *title = NULL; gdouble popwidth, popheight; gdouble tx, ty; gdouble screen_ratio, page_ratio, scale; PopplerPage *page = NULL; /* no valid target size? */ if (pp->width <= 0 || pp->height <= 0) return TRUE; /* decide which page to render - if any */ mypage_i = pagenumForPort(pp); if (mypage_i < 0 || mypage_i >= doc_n_pages) { /* We don't do any drawing and set the frame's title to "X". * Thus, we'll end up with an "empty" frame. */ if (pp->frame != NULL) gtk_frame_set_label(GTK_FRAME(pp->frame), "X"); return TRUE; } else { /* update frame title */ if (pp->frame != NULL) { title = g_strdup_printf("Slide %d / %d", mypage_i + 1, doc_n_pages); gtk_frame_set_label(GTK_FRAME(pp->frame), title); g_free(title); } } /* if note-control is active, print current page number if on * "main" frame. (don't do this on the beamer because it could be * locked.) * this allows you to attach any kind of other program or script * which can show notes for a specific slide. simply pipe the * output of pdfpres to your other tool. */ if (pp->offset == 0 && !pp->isBeamer) { printNote(doc_page + 1); if (runpref.do_notectrl) { printf("%d\n", doc_page + 1); fflush(stdout); } } /* Get the page and it's size from the document. */ page = poppler_document_get_page(doc, mypage_i); poppler_page_get_size(page, &popwidth, &popheight); /* Set page number */ if (pp->isBeamer) { gtk_label_set_text(GTK_LABEL(curPageLabel), g_strdup_printf("%s/%d", poppler_page_get_label(page), doc_last_page)); } /* Select fit mode. */ page_ratio = popwidth / popheight; screen_ratio = (double)pp->width / (double)pp->height; if (runpref.fit_mode == FIT_PAGE) { /* That's it: Compare screen and page ratio. This * will cover all 4 cases that could happen. */ if (screen_ratio > page_ratio) myfitmode = FIT_HEIGHT; else myfitmode = FIT_WIDTH; } else myfitmode = runpref.fit_mode; switch (myfitmode) { case FIT_HEIGHT: /* Fit size. */ h = pp->height; w = h * page_ratio; scale = h / popheight; /* Center page. */ tx = (pp->width - popwidth * scale) * 0.5; ty = 0; break; case FIT_WIDTH: w = pp->width; h = w / page_ratio; scale = w / popwidth; tx = 0; ty = (pp->height - popheight * scale) * 0.5; break; } /* A black background on beamer frame. Push and pop cairo contexts, so we have a * clean state afterwards. */ if (pp->isBeamer) { cairo_save(cr); cairo_set_source_rgb(cr, 0, 0, 0); cairo_rectangle(cr, 0, 0, pp->width, pp->height); cairo_fill(cr); cairo_restore(cr); /* center page on beamer */ cairo_translate(cr, tx, ty); } else { cairo_translate(cr, tx, 0); } /* Render the page */ cairo_scale(cr, scale, scale); poppler_page_render(page, cr); /* We no longer need that page. */ g_object_unref(G_OBJECT(page)); /* Nobody else draws to this widget. */ return TRUE; }
void finestra(struttura *str) { GtkWidget *frame, *winbox, *box,*table;//nuovo x lista GtkWidget **buttonArray; int i, x, y; char s_i[3]; /*Definiamo vettore che contiene gli indici delle posizioni possibili dell'interfaccia*/ char s[NUM_OF_BUTTONS][10]={"1","2 abc","3 def","4 ghi","5 jkl","6 mno","7 pqrs","8 tuv","9 wxyz","⇧ shift","0 +","PT","del","space","↵","sf","tab","ins","→","↓","."}; /* GDK_GRAVITY_SOUTH_WEST is the reference point corresponding at the lower left corner -> position 1 GDK_GRAVITY_SOUTH is the reference point corresponding at the middle of the lower edge -> position 2 GDK_GRAVITY_SOUTH_EAST is the reference point corresponding at the lower right corner -> position 3 */ str->window = gtk_window_new (GTK_WINDOW_POPUP); gtk_window_set_default_size (GTK_WINDOW(str->window), WINDOW_WIDTH, WINDOW_HEIGHT); winbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (str->window), winbox); gtk_widget_show (winbox); /* Crea una Frame */ frame = gtk_frame_new(NULL); gtk_container_add(GTK_CONTAINER(winbox), frame); /* Setta l'etichetta della frame */ gtk_frame_set_label( GTK_FRAME(frame), "Keyboard" ); gtk_widget_show (frame); box = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (frame), box); gtk_widget_show (box); buttonArray = (GtkWidget**)g_malloc((NUM_OF_BUTTONS)*sizeof(GtkButton**)); table = gtk_table_new(NUM_OF_ROWS, NUM_OF_COLUMNS, TRUE); gtk_table_set_row_spacings(GTK_TABLE(table), 1); gtk_table_set_col_spacings(GTK_TABLE(table), 1); x=y=0; for(i=1; i<=NUM_OF_BUTTONS;i++) { buttonArray[i] = gtk_button_new_with_label(s[i-1]); gtk_widget_set_size_request(buttonArray[i],60,40); gtk_table_attach_defaults(GTK_TABLE(table), buttonArray[i], x, x+1, y, y+1); supportoButtonTable(s_i,i); gtk_widget_set_name(buttonArray[i],s_i); g_signal_connect(G_OBJECT(buttonArray[i]), "clicked", G_CALLBACK(button_clicked),str); if(++x==NUM_OF_COLUMNS) { x=0; y++; } } gtk_box_pack_start(GTK_BOX(box), table, FALSE, FALSE, 0); /* Crea una Label per i tasti Shift e Ctrl */ str->mylabel = gtk_label_new ("Shift off"); gtk_widget_set_usize(str->mylabel, 0, 1); gtk_container_add(GTK_CONTAINER(box), str->mylabel); gtk_widget_show (str->mylabel); /* Crea una Lista per il T9 */ str->tp.gtklist=gtk_list_new(); gtk_list_set_selection_mode((GtkList *)str->tp.gtklist, GTK_SELECTION_SINGLE); str->tp.scrolled_window=gtk_scrolled_window_new(NULL,NULL); gtk_widget_set_usize(str->tp.scrolled_window, 0,S_W_MAIN);//75// gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (str->tp.scrolled_window),GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(str->tp.scrolled_window),str->tp.gtklist); gtk_container_add(GTK_CONTAINER(box),str->tp.scrolled_window); gtk_widget_show(str->tp.scrolled_window); gtk_widget_show(str->tp.gtklist); gtk_signal_connect(GTK_OBJECT(str->tp.gtklist),"selection_changed",GTK_SIGNAL_FUNC(sigh_print_selection),str);//nuovo x lista /* Crea una Label per il T9 */ str->mylabel2 = gtk_label_new ("PT off"); gtk_widget_set_usize(str->mylabel2,0, 1); gtk_container_add(GTK_CONTAINER(box),str->mylabel2); gtk_widget_show (str->mylabel2); /* Crea uno status icon per la minimizzazione */ str->tray_icon = gtk_status_icon_new(); g_signal_connect(G_OBJECT(str->tray_icon), "activate",G_CALLBACK(tray_icon_on_click), str); gtk_status_icon_set_from_icon_name(str->tray_icon,GTK_STOCK_MEDIA_STOP); gtk_status_icon_set_from_file(str->tray_icon,PATH_IMG); gtk_status_icon_set_tooltip(str->tray_icon,"Keyboard Tray Icon"); gtk_status_icon_set_visible(str->tray_icon, FALSE); gtk_widget_show_all(str->window); /*salviamo le dim massime dello schermo corrente*/ getMaxScreen(str); ins(str); // gtk_main (); }