END_HANDLER
BUTTON_CLICKED(setDefaultExportOptions)
{
nsoption_set_int(margin_top, DEFAULT_MARGIN_TOP_MM);
nsoption_set_int(margin_bottom, DEFAULT_MARGIN_BOTTOM_MM);
nsoption_set_int(margin_left, DEFAULT_MARGIN_LEFT_MM);
nsoption_set_int(margin_right, DEFAULT_MARGIN_RIGHT_MM);
nsoption_set_int(export_scale, DEFAULT_EXPORT_SCALE * 100);
nsoption_set_bool(suppress_images, false);
nsoption_set_bool(remove_backgrounds, false);
nsoption_set_bool(enable_loosening, true);
nsoption_set_bool(enable_PDF_compression, true);
nsoption_set_bool(enable_PDF_password, false);
SET_SPIN(spinMarginTop, nsoption_int(margin_top));
SET_SPIN(spinMarginBottom, nsoption_int(margin_bottom));
SET_SPIN(spinMarginLeft, nsoption_int(margin_left));
SET_SPIN(spinMarginRight, nsoption_int(margin_right));
SET_SPIN(spinExportScale, nsoption_int(export_scale));
SET_CHECK(checkSuppressImages, nsoption_bool(suppress_images));
SET_CHECK(checkRemoveBackgrounds, nsoption_bool(remove_backgrounds));
SET_CHECK(checkCompressPDF, nsoption_bool(enable_PDF_compression));
SET_CHECK(checkPasswordPDF, nsoption_bool(enable_PDF_password));
SET_CHECK(checkFitPage, nsoption_bool(enable_loosening));
}
struct NewMenu *ami_create_menu(struct gui_window_2 *gwin)
{
int i;
gwin->menu = AllocVecTags(sizeof(struct NewMenu) * (AMI_MENU_AREXX_MAX + 1),
AVT_ClearWithValue, 0, TAG_DONE);
ami_init_menulabs(gwin);
ami_menu_scan(ami_tree_get_tree(hotlist_window), gwin);
ami_menu_arexx_scan(gwin);
gwin = ami_menu_layout(gwin);
#if defined(WITH_JS) || defined(WITH_MOZJS)
gwin->menu[M_JS].nm_Flags = CHECKIT | MENUTOGGLE;
if(nsoption_bool(enable_javascript) == true)
gwin->menu[M_JS].nm_Flags |= CHECKED;
#endif
gwin->menu[M_PRINT].nm_Flags = NM_ITEMDISABLED;
gwin->menu[M_IMGFORE].nm_Flags = CHECKIT | MENUTOGGLE;
if(nsoption_bool(foreground_images) == true)
gwin->menu[M_IMGFORE].nm_Flags |= CHECKED;
gwin->menu[M_IMGBACK].nm_Flags = CHECKIT | MENUTOGGLE;
if(nsoption_bool(background_images) == true)
gwin->menu[M_IMGBACK].nm_Flags |= CHECKED;
/* Set up scheduler to refresh the hotlist menu */
if(nsoption_int(menu_refresh) > 0)
schedule(nsoption_int(menu_refresh), (void *)ami_menu_refresh, gwin);
return(gwin->menu);
}
END_HANDLER
COMBO_CHANGED(comboProxyType, http_proxy_auth)
{
LOG(("proxy auth: %d", nsoption_int(http_proxy_auth)));
switch (nsoption_int(http_proxy_auth)) {
case 0:
nsoption_set_bool(http_proxy, false);
nsoption_set_int(http_proxy_auth, OPTION_HTTP_PROXY_AUTH_NONE);
break;
case 1:
nsoption_set_bool(http_proxy, true);
nsoption_set_int(http_proxy_auth, OPTION_HTTP_PROXY_AUTH_NONE);
break;
case 2:
nsoption_set_bool(http_proxy, true);
nsoption_set_int(http_proxy_auth, OPTION_HTTP_PROXY_AUTH_BASIC);
break;
case 3:
nsoption_set_bool(http_proxy, true);
nsoption_set_int(http_proxy_auth, OPTION_HTTP_PROXY_AUTH_NTLM);
break;
}
gboolean sensitive = (!proxy_type == 0);
gtk_widget_set_sensitive(entryProxyHost, sensitive);
gtk_widget_set_sensitive(entryProxyPort, sensitive);
gtk_widget_set_sensitive(entryProxyUser, sensitive);
gtk_widget_set_sensitive(entryProxyPassword, sensitive);
}
struct gui_window *
gui_create_browser_window(struct browser_window *bw,
struct browser_window *clone,
bool new_tab)
{
struct gui_window *gw;
gw = calloc(1, sizeof(struct gui_window));
if (gw == NULL)
return NULL;
/* seems we need to associate the gui window with the underlying
* browser window
*/
gw->bw = bw;
create_normal_browser_window(gw, nsoption_int(fb_furniture_size));
gw->localhistory = fb_create_localhistory(bw, fbtk, nsoption_int(fb_furniture_size));
/* map and request redraw of gui window */
fbtk_set_mapping(gw->window, true);
return gw;
}
/* exported function documented in render/font_internal.h */
void font_plot_style_from_css(const css_computed_style *css,
plot_font_style_t *fstyle)
{
lwc_string **families;
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
css_color col;
fstyle->family = plot_font_generic_family(
css_computed_font_family(css, &families));
css_computed_font_size(css, &length, &unit);
fstyle->size = FIXTOINT(FMUL(nscss_len2pt(length, unit),
INTTOFIX(FONT_SIZE_SCALE)));
/* Clamp font size to configured minimum */
if (fstyle->size < (nsoption_int(font_min_size) * FONT_SIZE_SCALE) / 10)
fstyle->size = (nsoption_int(font_min_size) * FONT_SIZE_SCALE) / 10;
fstyle->weight = plot_font_weight(css_computed_font_weight(css));
fstyle->flags = plot_font_flags(css_computed_font_style(css),
css_computed_font_variant(css));
css_computed_color(css, &col);
fstyle->foreground = nscss_color_to_ns(col);
fstyle->background = 0;
}
/* Get a font style for a text input */
static inline void
fb_text_font_style(fbtk_widget_t *widget, int *font_height, int *padding,
plot_font_style_t *font_style)
{
if (widget->u.text.outline)
*padding = 1;
else
*padding = 0;
//#ifdef FB_USE_FREETYPE
if (!nsoption_bool(bitmap_fonts)) {
*padding += widget->height / 6;
*font_height = widget->height - *padding - *padding;
}
else {
*font_height = FB_FONT_HEIGHT;
*padding = (widget->height - *padding - *font_height) / 2;
}
font_style->family = PLOT_FONT_FAMILY_SANS_SERIF;
if (!nsoption_bool(bitmap_fonts))
#ifdef AGA
font_style->size = (nsoption_int(gui_font_size))*(790-nsoption_int(browser_dpi));
#else
font_style->size = nsoption_int(gui_font_size)*(790-nsoption_int(browser_dpi));
#endif
else
void Proxy(struct Hook *h, Object *o)
{
int num;
get(obj->CY_Proxy_type, MUIA_Cycle_Active, &var);
num = (int)var;
if (num == 0)
{
set(obj->STR_Host, MUIA_Disabled, TRUE);
set(obj->STR_Port, MUIA_Disabled, TRUE);
set(obj->STR_Username, MUIA_Disabled, TRUE);
set(obj->STR_Password, MUIA_Disabled, TRUE);
set(obj->STR_Bypass, MUIA_Disabled, TRUE);
nsoption_bool(http_proxy) = false;
nsoption_int(http_proxy_auth) = OPTION_HTTP_PROXY_AUTH_NONE;
}
else if (num == 1)
{
set(obj->STR_Username, MUIA_Disabled, TRUE);
set(obj->STR_Password, MUIA_Disabled, TRUE);
nsoption_bool(http_proxy) = true;
nsoption_int(http_proxy_auth) = OPTION_HTTP_PROXY_AUTH_NONE;
}
else if (num == 2)
{
nsoption_bool(http_proxy) = true;
nsoption_int(http_proxy_auth) = OPTION_HTTP_PROXY_AUTH_BASIC;
}
}
static nserror
ami_history_global_create_window(struct ami_history_global_window *history_win)
{
struct ami_corewindow *ami_cw = (struct ami_corewindow *)&history_win->core;
ULONG refresh_mode = WA_SmartRefresh;
if(nsoption_bool(window_simple_refresh) == true) {
refresh_mode = WA_SimpleRefresh;
}
ami_cw->objects[GID_CW_WIN] = WindowObj,
WA_ScreenTitle, ami_gui_get_screen_title(),
WA_Title, ami_cw->wintitle,
WA_Activate, TRUE,
WA_DepthGadget, TRUE,
WA_DragBar, TRUE,
WA_CloseGadget, TRUE,
WA_SizeGadget, TRUE,
WA_SizeBRight, TRUE,
WA_Top, nsoption_int(history_window_ypos),
WA_Left, nsoption_int(history_window_xpos),
WA_Width, nsoption_int(history_window_xsize),
WA_Height, nsoption_int(history_window_ysize),
WA_PubScreen, scrn,
WA_ReportMouse, TRUE,
refresh_mode, TRUE,
WA_IDCMP, IDCMP_MOUSEMOVE | IDCMP_MOUSEBUTTONS | IDCMP_NEWSIZE |
IDCMP_RAWKEY | IDCMP_GADGETUP | IDCMP_IDCMPUPDATE |
IDCMP_EXTENDEDMOUSE | IDCMP_SIZEVERIFY | IDCMP_REFRESHWINDOW,
WINDOW_IDCMPHook, &ami_cw->idcmp_hook,
WINDOW_IDCMPHookBits, IDCMP_IDCMPUPDATE | IDCMP_EXTENDEDMOUSE |
IDCMP_SIZEVERIFY | IDCMP_REFRESHWINDOW,
WINDOW_SharedPort, sport,
WINDOW_HorizProp, 1,
WINDOW_VertProp, 1,
WINDOW_UserData, history_win,
WINDOW_MenuStrip, ami_history_global_menu_create(history_win),
WINDOW_MenuUserData, WGUD_HOOK,
WINDOW_IconifyGadget, FALSE,
WINDOW_Position, WPOS_CENTERSCREEN,
WINDOW_ParentGroup, ami_cw->objects[GID_CW_MAIN] = LayoutVObj,
LAYOUT_AddChild, ami_cw->objects[GID_CW_DRAW] = SpaceObj,
GA_ID, GID_CW_DRAW,
SPACE_Transparent, TRUE,
SPACE_BevelStyle, BVS_DISPLAY,
GA_RelVerify, TRUE,
SpaceEnd,
EndGroup,
EndWindow;
if(ami_cw->objects[GID_CW_WIN] == NULL) {
return NSERROR_NOMEM;
}
return NSERROR_OK;
}
bool ro_gui_options_image_initialise(wimp_w w)
{
int i;
/* load the sprite file */
if (example_users == 0) {
char pathname[256];
snprintf(pathname, 256, "%s.Resources.Image", NETSURF_DIR);
pathname[255] = '\0';
example_images = ro_gui_load_sprite_file(pathname);
if (!example_images)
return false;
}
example_users++;
/* set the current values */
for (i = 0; (i < 4); i++) {
if ((unsigned int)nsoption_int(plot_fg_quality) == tinct_options[i])
ro_gui_set_icon_string(w, IMAGE_FOREGROUND_FIELD,
image_quality_menu->entries[i].
data.indirected_text.text, true);
if ((unsigned int)nsoption_int(plot_bg_quality) == tinct_options[i])
ro_gui_set_icon_string(w, IMAGE_BACKGROUND_FIELD,
image_quality_menu->entries[i].
data.indirected_text.text, true);
}
ro_gui_set_icon_decimal(w, IMAGE_SPEED_FIELD,
nsoption_int(minimum_gif_delay), 2);
ro_gui_set_icon_selected_state(w, IMAGE_DISABLE_ANIMATION,
!nsoption_bool(animate_images));
ro_gui_options_update_shading(w);
/* register icons */
ro_gui_wimp_event_register_menu_gright(w, IMAGE_FOREGROUND_FIELD,
IMAGE_FOREGROUND_MENU, image_quality_menu);
ro_gui_wimp_event_register_menu_gright(w, IMAGE_BACKGROUND_FIELD,
IMAGE_BACKGROUND_MENU, image_quality_menu);
ro_gui_wimp_event_register_text_field(w, IMAGE_SPEED_TEXT);
ro_gui_wimp_event_register_numeric_field(w, IMAGE_SPEED_FIELD,
IMAGE_SPEED_INC, IMAGE_SPEED_DEC, 0, 6000, 10, 2);
ro_gui_wimp_event_register_checkbox(w, IMAGE_DISABLE_ANIMATION);
ro_gui_wimp_event_register_text_field(w, IMAGE_SPEED_CS);
ro_gui_wimp_event_register_redraw_window(w,
ro_gui_options_image_redraw);
ro_gui_wimp_event_register_mouse_click(w,
ro_gui_options_image_click);
ro_gui_wimp_event_register_menu_selection(w,
ro_gui_options_image_update);
ro_gui_wimp_event_register_cancel(w, IMAGE_CANCEL_BUTTON);
ro_gui_wimp_event_register_ok(w, IMAGE_OK_BUTTON,
ro_gui_options_image_ok);
ro_gui_wimp_event_set_help_prefix(w, "HelpImageConfig");
ro_gui_wimp_event_memorise(w);
return true;
}
void ami_print(struct hlcache_handle *c, int copies)
{
double height;
float scale = nsoption_int(print_scale) / 100.0;
if(ami_print_info.msgport == NULL)
ami_print_init();
#ifdef __amigaos4__
if(!(ami_print_info.PReq =
(struct IODRPTagsReq *)AllocSysObjectTags(ASOT_IOREQUEST,
ASOIOR_Size, sizeof(struct IODRPTagsReq),
ASOIOR_ReplyPort, ami_print_info.msgport,
ASO_NoTrack, FALSE,
TAG_DONE))) return;
#else
if(!(ami_print_info.PReq =
(struct IODRPTagsReq *)CreateIORequest(ami_print_info.msgport,
sizeof(struct IODRPTagsReq)))) return;
#endif
if(OpenDevice("printer.device", nsoption_int(printer_unit),
(struct IORequest *)ami_print_info.PReq, 0))
{
amiga_warn_user("CompError","printer.device");
return;
}
ami_print_info.PD = (struct PrinterData *)ami_print_info.PReq->io_Device;
ami_print_info.PED = &ami_print_info.PD->pd_SegmentData->ps_PED;
ami_print_info.ps = print_make_settings(PRINT_DEFAULT, nsurl_access(hlcache_handle_get_url(c)), ami_layout_table);
ami_print_info.ps->page_width = ami_print_info.PED->ped_MaxXDots;
ami_print_info.ps->page_height = ami_print_info.PED->ped_MaxYDots;
ami_print_info.ps->scale = scale;
if(!print_set_up(c, &amiprinter, ami_print_info.ps, &height))
{
amiga_warn_user("PrintError","print_set_up() returned false");
ami_print_close_device();
return;
}
height *= ami_print_info.ps->scale;
ami_print_info.pages = height / ami_print_info.ps->page_height;
ami_print_info.c = c;
ami_print_progress();
while(ami_print_cont()); /* remove while() for async printing */
}
bool ro_gui_options_image_ok(wimp_w w)
{
ro_gui_options_image_read(w,
(unsigned int *)&nsoption_int(plot_bg_quality),
(unsigned int *)&nsoption_int(plot_fg_quality));
nsoption_set_int(minimum_gif_delay,
ro_gui_get_icon_decimal(w, IMAGE_SPEED_FIELD, 2));
nsoption_set_bool(animate_images,
!ro_gui_get_icon_selected_state(w,
IMAGE_DISABLE_ANIMATION));
ro_gui_save_options();
return true;
}
/**
* Choose and dispatch a single job. Return false if we failed to dispatch
* anything.
*
* We don't check the overall dispatch size here because we're not called unless
* there is room in the fetch queue for us.
*/
static bool fetch_choose_and_dispatch(void)
{
bool same_host;
struct fetch *queueitem;
queueitem = queue_ring;
do {
/* We can dispatch the selected item if there is room in the
* fetch ring
*/
int countbyhost;
RING_COUNTBYLWCHOST(struct fetch, fetch_ring, countbyhost,
queueitem->host);
if (countbyhost < nsoption_int(max_fetchers_per_host)) {
/* We can dispatch this item in theory */
return fetch_dispatch_job(queueitem);
}
/* skip over other items with the same host */
same_host = true;
while (same_host == true && queueitem->r_next != queue_ring) {
if (lwc_string_isequal(queueitem->host,
queueitem->r_next->host, &same_host) ==
lwc_error_ok && same_host == true) {
queueitem = queueitem->r_next;
}
}
queueitem = queueitem->r_next;
} while (queueitem != queue_ring);
return false;
}
END_HANDLER
COMBO_CHANGED(combotheme, current_theme)
{
nsgtk_scaffolding *current = scaf_list;
char *name;
if (nsoption_int(current_theme) != 0) {
if (nsgtk_theme_name() != NULL)
free(nsgtk_theme_name());
name = nsgtk_combo_box_text_get_active_text(combotheme);
if (name != NULL) {
nsgtk_theme_set_name(name);
nsgtk_theme_prepare();
/* possible name leak */
}
} else if (nsgtk_theme_name() != NULL) {
free(nsgtk_theme_name());
nsgtk_theme_set_name(NULL);
}
while (current) {
nsgtk_theme_implement(current);
current = nsgtk_scaffolding_iterate(current);
}
}
/**
* Tests whether a bitmap has an opaque alpha channel
*
* \param bitmap a bitmap, as returned by bitmap_create()
* \return whether the bitmap is opaque
*/
bool bitmap_test_opaque(void *bitmap)
{
int tst;
struct bitmap *bm = bitmap;
if (bitmap == NULL) {
LOG(("NULL bitmap!"));
return false;
}
if( nsoption_int(atari_transparency) == 0 ){
return( true );
}
tst = bm->width * bm->height;
while (tst-- > 0) {
if (bm->pixdata[(tst << 2) + 3] != 0xff) {
LOG(("bitmap %p has transparency",bm));
return false;
}
}
LOG(("bitmap %p is opaque", bm));
return true;
}
static nserror nsgtk_option_init(int *pargc, char** argv)
{
nserror ret;
char *choices = NULL;
/* user options setup */
ret = nsoption_init(set_defaults, &nsoptions, &nsoptions_default);
if (ret != NSERROR_OK) {
return ret;
}
/* Attempt to load the user choices */
ret = netsurf_mkpath(&choices, NULL, 2, nsgtk_config_home, "Choices");
if (ret == NSERROR_OK) {
nsoption_read(choices, nsoptions);
free(choices);
}
/* overide loaded options with those from commandline */
nsoption_commandline(pargc, argv, nsoptions);
/* ensure all options fall within sensible bounds */
/* Attempt to handle nonsense status bar widths. These may exist
* in people's Choices as the GTK front end used to abuse the
* status bar width option by using it for an absolute value in px.
* The GTK front end now correctly uses it as a proportion of window
* width. Here we assume that a value of less than 15% is wrong
* and set to the default two thirds. */
if (nsoption_int(toolbar_status_size) < 1500) {
nsoption_set_int(toolbar_status_size, 6667);
}
return NSERROR_OK;
}
END_HANDLER
COMBO_CHANGED(comboButtonType, button_type)
{
nsgtk_scaffolding *current = scaf_list;
nsoption_set_int(button_type, nsoption_int(button_type) + 1);
/* value of 0 is reserved for 'unset' */
while (current) {
nsgtk_scaffolding_reset_offset(current);
switch(nsoption_int(button_type)) {
case 1:
gtk_toolbar_set_style(
GTK_TOOLBAR(nsgtk_scaffolding_toolbar(current)),
GTK_TOOLBAR_ICONS);
gtk_toolbar_set_icon_size(
GTK_TOOLBAR(nsgtk_scaffolding_toolbar(current)),
GTK_ICON_SIZE_SMALL_TOOLBAR);
break;
case 2:
gtk_toolbar_set_style(
GTK_TOOLBAR(nsgtk_scaffolding_toolbar(current)),
GTK_TOOLBAR_ICONS);
gtk_toolbar_set_icon_size(
GTK_TOOLBAR(nsgtk_scaffolding_toolbar(current)),
GTK_ICON_SIZE_LARGE_TOOLBAR);
break;
case 3:
gtk_toolbar_set_style(
GTK_TOOLBAR(nsgtk_scaffolding_toolbar(current)),
GTK_TOOLBAR_BOTH);
gtk_toolbar_set_icon_size(
GTK_TOOLBAR(nsgtk_scaffolding_toolbar(current)),
GTK_ICON_SIZE_LARGE_TOOLBAR);
break;
case 4:
gtk_toolbar_set_style(
GTK_TOOLBAR(nsgtk_scaffolding_toolbar(current)),
GTK_TOOLBAR_TEXT);
default:
break;
}
current = nsgtk_scaffolding_iterate(current);
}
}
bool ro_gui_options_fonts_ok(wimp_w w)
{
unsigned int i;
nsoption_set_int(font_size,
ro_gui_get_icon_decimal(w, FONT_DEFAULT_SIZE, 1));
nsoption_set_int(font_min_size,
ro_gui_get_icon_decimal(w, FONT_MINIMUM_SIZE, 1));
if (nsoption_int(font_size) < nsoption_int(font_min_size)) {
nsoption_set_int(font_size, nsoption_int(font_min_size));
ro_gui_set_icon_decimal(w, FONT_DEFAULT_SIZE, nsoption_int(font_size), 1);
}
nsoption_set_charp(font_sans,
strdup(ro_gui_get_icon_string(w, FONT_SANS_FIELD)));
nsoption_set_charp(font_serif,
strdup(ro_gui_get_icon_string(w, FONT_SERIF_FIELD)));
nsoption_set_charp(font_mono,
strdup(ro_gui_get_icon_string(w, FONT_MONOSPACE_FIELD)));
nsoption_set_charp(font_cursive,
strdup(ro_gui_get_icon_string(w, FONT_CURSIVE_FIELD)));
nsoption_set_charp(font_fantasy,
strdup(ro_gui_get_icon_string(w, FONT_FANTASY_FIELD)));
for (i = 0; i != 5; i++) {
if (!strcmp(font_names[i], ro_gui_get_icon_string(w,
FONT_DEFAULT_FIELD)))
break;
}
if (i == 5)
/* this should never happen, but still */
i = 0;
nsoption_set_int(font_default, i);
ro_gui_save_options();
return true;
}
bool ro_gui_options_fonts_initialise(wimp_w w)
{
/* set the current values */
ro_gui_set_icon_decimal(w, FONT_DEFAULT_SIZE, nsoption_int(font_size), 1);
ro_gui_set_icon_decimal(w, FONT_MINIMUM_SIZE, nsoption_int(font_min_size), 1);
ro_gui_set_icon_string(w, FONT_SANS_FIELD, nsoption_charp(font_sans), true);
ro_gui_set_icon_string(w, FONT_SERIF_FIELD, nsoption_charp(font_serif), true);
ro_gui_set_icon_string(w, FONT_MONOSPACE_FIELD, nsoption_charp(font_mono), true);
ro_gui_set_icon_string(w, FONT_CURSIVE_FIELD, nsoption_charp(font_cursive), true);
ro_gui_set_icon_string(w, FONT_FANTASY_FIELD, nsoption_charp(font_fantasy), true);
ro_gui_set_icon_string(w, FONT_DEFAULT_FIELD,
font_names[nsoption_int(font_default)], true);
if (!ro_gui_options_fonts_init_menu())
return false;
/* initialise all functions for a newly created window */
ro_gui_wimp_event_register_menu_gright(w, FONT_SANS_FIELD,
FONT_SANS_MENU, rufl_family_menu);
ro_gui_wimp_event_register_menu_gright(w, FONT_SERIF_FIELD,
FONT_SERIF_MENU, rufl_family_menu);
ro_gui_wimp_event_register_menu_gright(w, FONT_MONOSPACE_FIELD,
FONT_MONOSPACE_MENU, rufl_family_menu);
ro_gui_wimp_event_register_menu_gright(w, FONT_CURSIVE_FIELD,
FONT_CURSIVE_MENU, rufl_family_menu);
ro_gui_wimp_event_register_menu_gright(w, FONT_FANTASY_FIELD,
FONT_FANTASY_MENU, rufl_family_menu);
ro_gui_wimp_event_register_menu_gright(w, FONT_DEFAULT_FIELD,
FONT_DEFAULT_MENU, default_menu);
ro_gui_wimp_event_register_numeric_field(w, FONT_DEFAULT_SIZE,
FONT_DEFAULT_INC, FONT_DEFAULT_DEC, 50, 1000, 1, 1);
ro_gui_wimp_event_register_numeric_field(w, FONT_MINIMUM_SIZE,
FONT_MINIMUM_INC, FONT_MINIMUM_DEC, 10, 500, 1, 1);
ro_gui_wimp_event_register_button(w, FONT_DEFAULT_BUTTON,
ro_gui_options_fonts_default);
ro_gui_wimp_event_register_cancel(w, FONT_CANCEL_BUTTON);
ro_gui_wimp_event_register_ok(w, FONT_OK_BUTTON,
ro_gui_options_fonts_ok);
ro_gui_wimp_event_set_help_prefix(w, "HelpFontConfig");
ro_gui_wimp_event_memorise(w);
return true;
}
/**
* Plot an image at the given coordinates using the method specified
*
* \param area The sprite area containing the sprite
* \param x Left edge of sprite
* \param y Top edge of sprite
* \param req_width The requested width of the sprite
* \param req_height The requested height of the sprite
* \param width The actual width of the sprite
* \param height The actual height of the sprite
* \param background_colour The background colour to blend to
* \param repeatx Repeat the image in the x direction
* \param repeaty Repeat the image in the y direction
* \param background Use background image settings (otherwise foreground)
* \param type The plot method to use
* \return true on success, false otherwise
*/
bool image_redraw(osspriteop_area *area, int x, int y, int req_width,
int req_height, int width, int height,
colour background_colour,
bool repeatx, bool repeaty, bool background, image_type type)
{
unsigned int tinct_options;
/* failed decompression/loading can result in no image being present */
if (!area)
return false;
osspriteop_id header = (osspriteop_id)
((char*) area + area->first);
req_width *= 2;
req_height *= 2;
width *= 2;
height *= 2;
tinct_options = background ? nsoption_int(bg_plot_style) :
nsoption_int(fg_plot_style);
switch (type) {
case IMAGE_PLOT_TINCT_ALPHA:
return image_redraw_tinct(header, x, y,
req_width, req_height,
width, height,
background_colour,
repeatx, repeaty, true,
tinct_options);
case IMAGE_PLOT_TINCT_OPAQUE:
return image_redraw_tinct(header, x, y,
req_width, req_height,
width, height,
background_colour,
repeatx, repeaty, false,
tinct_options);
case IMAGE_PLOT_OS:
return image_redraw_os(header, x, y, req_width,
req_height, width, height);
default:
break;
}
return false;
}
/**
* Initialize font handling.
*
* Exits through die() on error.
*/
void nsfont_init(void)
{
const char *fallback;
rufl_code code;
nsfont_check_fonts();
LOG("Initialise RUfl");
code = rufl_init();
if (code != rufl_OK) {
if (code == rufl_FONT_MANAGER_ERROR)
LOG("rufl_init: rufl_FONT_MANAGER_ERROR: 0x%x: %s", rufl_fm_error->errnum, rufl_fm_error->errmess);
else
LOG("rufl_init: 0x%x", code);
die("The Unicode font library could not be initialized. "
"Please report this to the developers.");
}
LOG("RUfl initialised");
if (rufl_family_list_entries == 0)
die("No fonts could be found. At least one font must be "
"installed.");
fallback = nsfont_fallback_font();
nsfont_check_option(&nsoption_charp(font_sans), "Homerton", fallback);
nsfont_check_option(&nsoption_charp(font_serif), "Trinity", fallback);
nsfont_check_option(&nsoption_charp(font_mono), "Corpus", fallback);
nsfont_check_option(&nsoption_charp(font_cursive), "Churchill", fallback);
nsfont_check_option(&nsoption_charp(font_fantasy), "Sassoon", fallback);
if (nsoption_int(font_default) != PLOT_FONT_FAMILY_SANS_SERIF &&
nsoption_int(font_default) != PLOT_FONT_FAMILY_SERIF &&
nsoption_int(font_default) != PLOT_FONT_FAMILY_MONOSPACE &&
nsoption_int(font_default) != PLOT_FONT_FAMILY_CURSIVE &&
nsoption_int(font_default) != PLOT_FONT_FAMILY_FANTASY) {
nsoption_set_int(font_default, PLOT_FONT_FAMILY_SANS_SERIF);
}
}
void nsgtk_theme_init(void)
{
size_t len;
if (nsoption_int(current_theme) == 0) {
return;
}
len = SLEN("themelist") + strlen(res_dir_location) + 1;
char themefile[len];
snprintf(themefile, len, "%s%s", res_dir_location, "themelist");
nsgtk_scaffolding *list = scaf_list;
nsgtk_theme_verify(NULL);
FILE *fp = fopen(themefile, "r");
if (fp == NULL)
return;
char buf[50];
int row_count = 0;
while (fgets(buf, sizeof(buf), fp) != NULL) {
if (buf[0] == '\0')
continue;
if (row_count++ == nsoption_int(current_theme)) {
if (current_theme_name != NULL)
free(current_theme_name);
/* clear the '\n' ["\n\0"->"\0\0"] */
buf[strlen(buf) - 1] = '\0';
current_theme_name = strdup(buf);
break;
}
}
fclose(fp);
while (list != NULL) {
nsgtk_theme_implement(list);
list = nsgtk_scaffolding_iterate(list);
}
}
static struct gui_window *
gui_window_create(struct browser_window *bw,
struct gui_window *existing,
gui_window_create_flags flags)
{
struct gui_window *gw;
gw = calloc(1, sizeof(struct gui_window));
if (gw == NULL)
return NULL;
/* associate the gui window with the underlying browser window
*/
gw->bw = bw;
create_normal_browser_window(gw, nsoption_int(fb_furniture_size));
gw->localhistory = fb_create_localhistory(bw, fbtk, nsoption_int(fb_furniture_size));
/* map and request redraw of gui window */
fbtk_set_mapping(gw->window, true);
return gw;
}
/**
* Dispatch as many jobs as we have room to dispatch.
*/
static void fetch_dispatch_jobs(void)
{
int all_active, all_queued;
#ifdef DEBUG_FETCH_VERBOSE
struct fetch *q;
struct fetch *f;
#endif
if (!queue_ring)
return; /* Nothing to do, the queue is empty */
RING_GETSIZE(struct fetch, queue_ring, all_queued);
RING_GETSIZE(struct fetch, fetch_ring, all_active);
#ifdef DEBUG_FETCH_VERBOSE
LOG(("queue_ring %i, fetch_ring %i", all_queued, all_active));
q = queue_ring;
if (q) {
do {
LOG(("queue_ring: %s", q->url));
q = q->r_next;
} while (q != queue_ring);
}
f = fetch_ring;
if (f) {
do {
LOG(("fetch_ring: %s", f->url));
f = f->r_next;
} while (f != fetch_ring);
}
#endif
while ( all_queued && all_active < nsoption_int(max_fetchers) ) {
/*LOG(("%d queued, %d fetching", all_queued, all_active));*/
if (fetch_choose_and_dispatch()) {
all_queued--;
all_active++;
} else {
/* Either a dispatch failed or we ran out. Just stop */
break;
}
}
fetch_active = (all_active > 0);
#ifdef DEBUG_FETCH_VERBOSE
LOG(("Fetch ring is now %d elements.", all_active));
LOG(("Queue ring is now %d elements.", all_queued));
#endif
}
END_HANDLER
COMBO_CHANGED(comboTabPosition, position_tab)
{
nsgtk_scaffolding *current = scaf_list;
nsoption_set_int(button_type, nsoption_int(button_type) + 1);
/* value of 0 is reserved for 'unset' */
while (current) {
nsgtk_scaffolding_reset_offset(current);
nsgtk_reflow_all_windows();
current = nsgtk_scaffolding_iterate(current);
}
}
/**
* Cache a CURL handle for the provided host (if wanted)
*/
static void fetch_curl_cache_handle(CURL *handle, lwc_string *host)
{
#if LIBCURL_VERSION_NUM >= 0x071e00
/* 7.30.0 or later has its own connection caching; suppress ours */
curl_easy_cleanup(handle);
return;
#else
struct cache_handle *h = 0;
int c;
RING_FINDBYLWCHOST(curl_handle_ring, h, host);
if (h) {
/* Already have a handle cached for this hostname */
curl_easy_cleanup(handle);
return;
}
/* We do not have a handle cached, first up determine if the cache is full */
RING_GETSIZE(struct cache_handle, curl_handle_ring, c);
if (c >= nsoption_int(max_cached_fetch_handles)) {
/* Cache is full, so, we rotate the ring by one and
* replace the oldest handle with this one. We do this
* without freeing/allocating memory (except the
* hostname) and without removing the entry from the
* ring and then re-inserting it, in order to be as
* efficient as we can.
*/
if (curl_handle_ring != NULL) {
h = curl_handle_ring;
curl_handle_ring = h->r_next;
curl_easy_cleanup(h->handle);
h->handle = handle;
lwc_string_unref(h->host);
h->host = lwc_string_ref(host);
} else {
/* Actually, we don't want to cache any handles */
curl_easy_cleanup(handle);
}
return;
}
/* The table isn't full yet, so make a shiny new handle to add to the ring */
h = (struct cache_handle*)malloc(sizeof(struct cache_handle));
h->handle = handle;
h->host = lwc_string_ref(host);
RING_INSERT(curl_handle_ring, h);
#endif
}
gboolean on_entryProxyPort_changed(GtkWidget *widget, gpointer data)
{
long port;
errno = 0;
port = strtol((char *)gtk_entry_get_text(GTK_ENTRY(entryProxyPort)),
NULL, 10) & 0xffff;
if ((port != 0) && (errno == 0)) {
nsoption_set_int(http_proxy_port, port);
} else {
char buf[32];
snprintf(buf, sizeof(buf), "%d", nsoption_int(http_proxy_port));
SET_ENTRY(entryProxyPort, buf);
}
return FALSE;
}
struct gui_window *
gui_create_browser_window(struct browser_window *bw,
struct browser_window *clone,
bool new_tab)
{
struct gui_window *gw;
LOG(("GCBW calloc"));
gw = calloc(1, sizeof(struct gui_window));
if (gw == NULL)
return NULL;
/* seems we need to associate the gui window with the underlying
* browser window
*/
LOG(("GCBW next.."));
gw->bw = bw;
LOG(("fb_furn_size is STUB now!..."));
//nsoption_int(fb_furniture_size);
LOG(("GCBW create normal window..."));
create_normal_browser_window(gw, 18); //nsoption_int(fb_furniture_size));
LOG(("GCBW create local history..."));
gw->localhistory = fb_create_localhistory(bw, fbtk, nsoption_int(fb_furniture_size));
/* map and request redraw of gui window */
LOG(("GCBW set mapping"));
fbtk_set_mapping(gw->window, true);
LOG(("GCBW OK!"));
return gw;
}
/**
* Callback to retrieve the User-Agent defaults for a CSS property.
*
* \param pw HTML document
* \param property Property to retrieve defaults for
* \param hint Pointer to hint object to populate
* \return CSS_OK on success,
* CSS_INVALID if the property should not have a user-agent default.
*/
css_error ua_default_for_property(void *pw, uint32_t property, css_hint *hint)
{
if (property == CSS_PROP_COLOR) {
hint->data.color = 0xff000000;
hint->status = CSS_COLOR_COLOR;
} else if (property == CSS_PROP_FONT_FAMILY) {
hint->data.strings = NULL;
switch (nsoption_int(font_default)) {
case PLOT_FONT_FAMILY_SANS_SERIF:
hint->status = CSS_FONT_FAMILY_SANS_SERIF;
break;
case PLOT_FONT_FAMILY_SERIF:
hint->status = CSS_FONT_FAMILY_SERIF;
break;
case PLOT_FONT_FAMILY_MONOSPACE:
hint->status = CSS_FONT_FAMILY_MONOSPACE;
break;
case PLOT_FONT_FAMILY_CURSIVE:
hint->status = CSS_FONT_FAMILY_CURSIVE;
break;
case PLOT_FONT_FAMILY_FANTASY:
hint->status = CSS_FONT_FAMILY_FANTASY;
break;
}
} else if (property == CSS_PROP_QUOTES) {
/** \todo Not exactly useful :) */
hint->data.strings = NULL;
hint->status = CSS_QUOTES_NONE;
} else if (property == CSS_PROP_VOICE_FAMILY) {
/** \todo Fix this when we have voice-family done */
hint->data.strings = NULL;
hint->status = 0;
} else {
return CSS_INVALID;
}
return CSS_OK;
}
bool ro_gui_options_security_initialise(wimp_w w)
{
/* set the current values */
ro_gui_set_icon_selected_state(w, SECURITY_REFERRER,
nsoption_bool(send_referer));
ro_gui_set_icon_integer(w, SECURITY_DURATION_FIELD,
nsoption_int(expire_url));
/* initialise all functions for a newly created window */
ro_gui_wimp_event_register_checkbox(w, SECURITY_REFERRER);
ro_gui_wimp_event_register_numeric_field(w, SECURITY_DURATION_FIELD,
SECURITY_DURATION_DEC, SECURITY_DURATION_INC,
0, 365, 1, 0);
ro_gui_wimp_event_register_button(w, SECURITY_DEFAULT_BUTTON,
ro_gui_options_security_default);
ro_gui_wimp_event_register_cancel(w, SECURITY_CANCEL_BUTTON);
ro_gui_wimp_event_register_ok(w, SECURITY_OK_BUTTON,
ro_gui_options_security_ok);
ro_gui_wimp_event_set_help_prefix(w, "HelpSecurityConfig");
ro_gui_wimp_event_memorise(w);
return true;
}
static void nsgtk_options_theme_combo(void) {
/* populate theme combo from themelist file */
GtkBox *box = GTK_BOX(gtk_builder_get_object(gladeFile, "themehbox"));
char buf[50];
size_t len = SLEN("themelist") + strlen(res_dir_location) + 1;
char themefile[len];
combotheme = nsgtk_combo_box_text_new();
if ((combotheme == NULL) || (box == NULL)) {
warn_user(messages_get("NoMemory"), 0);
return;
}
snprintf(themefile, len, "%sthemelist", res_dir_location);
FILE *fp = fopen((const char *)themefile, "r");
if (fp == NULL) {
LOG(("Failed opening themes file"));
warn_user("FileError", (const char *) themefile);
return;
}
while (fgets(buf, sizeof(buf), fp) != NULL) {
/* Ignore blank lines */
if (buf[0] == '\0')
continue;
/* Remove trailing \n */
buf[strlen(buf) - 1] = '\0';
nsgtk_combo_box_text_append_text(combotheme, buf);
}
fclose(fp);
gtk_combo_box_set_active(GTK_COMBO_BOX(combotheme),
nsoption_int(current_theme));
gtk_box_pack_start(box, combotheme, FALSE, TRUE, 0);
gtk_widget_show(combotheme);
}
