static struct nsgtk_edit_menu *nsgtk_menu_edit_submenu(GtkAccelGroup *group)
{
struct nsgtk_edit_menu *ret = malloc(sizeof(struct nsgtk_edit_menu));
if (ret == NULL) {
warn_user(messages_get("NoMemory"), 0);
return NULL;
}
ret->edit_menu = GTK_MENU(gtk_menu_new());
if (ret->edit_menu == NULL) {
warn_user(messages_get("NoMemory"), 0);
free(ret);
return NULL;
}
IMAGE_ITEM(edit, cut, gtkCut, ret, group);
IMAGE_ITEM(edit, copy, gtkCopy, ret, group);
IMAGE_ITEM(edit, paste, gtkPaste, ret, group);
IMAGE_ITEM(edit, delete, gtkDelete, ret, group);
ADD_SEP(edit, ret);
IMAGE_ITEM(edit, selectall, gtkSelectAll, ret, group);
ADD_SEP(edit, ret);
IMAGE_ITEM(edit, find, gtkFind, ret, group);
ADD_SEP(edit, ret);
IMAGE_ITEM(edit, preferences, gtkPreferences, ret, group);
return ret;
}
static LONG ami_misc_req(const char *message, uint32 type)
{
LONG ret = 0;
LOG("%s", message);
#ifdef __amigaos4__
ret = TimedDosRequesterTags(
TDR_TitleString, messages_get("NetSurf"),
TDR_FormatString, message,
TDR_GadgetString, messages_get("OK"),
TDR_ImageType, type,
TDR_Window, cur_gw ? cur_gw->shared->win : NULL,
TAG_DONE);
#else
struct EasyStruct easyreq = {
sizeof(struct EasyStruct),
0,
messages_get("NetSurf"),
message,
messages_get("OK"),
};
ret = EasyRequest(cur_gw ? cur_gw->shared->win : NULL, &easyreq, NULL);
#endif
return ret;
}
/**
* creates the file menu
* \param group The gtk 'global' accelerator reference
* \param parent The parent menu to attach to or NULL
*/
static struct nsgtk_file_menu *nsgtk_menu_file_submenu(GtkAccelGroup *group)
{
struct nsgtk_file_menu *fmenu;
fmenu = malloc(sizeof(struct nsgtk_file_menu));
if (fmenu == NULL) {
warn_user(messages_get("NoMemory"), 0);
return NULL;
}
fmenu->file_menu = GTK_MENU(gtk_menu_new());
if (fmenu->file_menu == NULL) {
warn_user(messages_get("NoMemory"), 0);
free(fmenu);
return NULL;
}
IMAGE_ITEM(file, newwindow, gtkNewWindow, fmenu, group);
IMAGE_ITEM(file, newtab, gtkNewTab, fmenu, group);
IMAGE_ITEM(file, openfile, gtkOpenFile, fmenu, group);
IMAGE_ITEM(file, closewindow, gtkCloseWindow, fmenu, group);
ADD_SEP(file, fmenu);
IMAGE_ITEM(file, savepage, gtkSavePage, fmenu, group);
IMAGE_ITEM(file, export, gtkExport, fmenu, group);
ADD_SEP(file, fmenu);
IMAGE_ITEM(file, printpreview, gtkPrintPreview, fmenu, group);
IMAGE_ITEM(file, print, gtkPrint, fmenu, group);
ADD_SEP(file, fmenu);
IMAGE_ITEM(file, quit, gtkQuitMenu, fmenu, group);
SET_SUBMENU(export, fmenu);
return fmenu;
}
static struct nsgtk_nav_menu *nsgtk_menu_nav_submenu(GtkAccelGroup *group)
{
struct nsgtk_nav_menu *ret = malloc(sizeof(struct nsgtk_nav_menu));
if (ret == NULL) {
warn_user(messages_get("NoMemory"), 0);
return NULL;
}
ret->nav_menu = GTK_MENU(gtk_menu_new());
if (ret->nav_menu == NULL) {
warn_user(messages_get("NoMemory"), 0);
free(ret);
return NULL;
}
IMAGE_ITEM(nav, back, gtkBack, ret, group);
IMAGE_ITEM(nav, forward, gtkForward, ret, group);
IMAGE_ITEM(nav, home, gtkHome, ret, group);
ADD_SEP(nav, ret);
IMAGE_ITEM(nav, localhistory, gtkLocalHistory, ret, group);
IMAGE_ITEM(nav, globalhistory, gtkGlobalHistory, ret, group);
ADD_SEP(nav, ret);
IMAGE_ITEM(nav, addbookmarks, gtkAddBookMarks, ret, group);
IMAGE_ITEM(nav, showbookmarks, gtkShowBookMarks, ret, group);
ADD_SEP(nav, ret);
IMAGE_ITEM(nav, showcookies, gtkShowCookies, ret, group);
ADD_SEP(nav, ret);
IMAGE_ITEM(nav, openlocation, gtkOpenLocation, ret, group);
return ret;
}
void warn_user(const char *warning, const char *detail)
{
Object *req = NULL;
char *utf8warning = ami_utf8_easy(messages_get(warning));
STRPTR bodytext = NULL;
LOG(("%s %s", warning, detail));
bodytext = ASPrintf("\33b%s\33n\n%s",
utf8warning != NULL ? utf8warning : warning, detail);
req = NewObject(REQUESTER_GetClass(), NULL,
REQ_Type, REQTYPE_INFO,
REQ_TitleText, messages_get("NetSurf"),
REQ_BodyText, bodytext,
REQ_GadgetText, messages_get("OK"),
#ifdef __amigaos4__
REQ_VarArgs,
REQ_Image, (struct Image *)REQIMAGE_WARNING,
/* REQ_CharSet, 106, */
#endif
TAG_DONE);
if (req) {
LONG result = IDoMethod(req, RM_OPENREQ, NULL, NULL, scrn);
DisposeObject(req);
}
if(bodytext) FreeVec(bodytext);
if(utf8warning) free(utf8warning);
}
int32 ami_warn_user_multi(const char *body, const char *opt1, const char *opt2, struct Window *win)
{
int res = 0;
char *utf8text = ami_utf8_easy(body);
char *utf8gadget1 = ami_utf8_easy(messages_get(opt1));
char *utf8gadget2 = ami_utf8_easy(messages_get(opt2));
char *utf8gadgets = ASPrintf("%s|%s", utf8gadget1, utf8gadget2);
free(utf8gadget1);
free(utf8gadget2);
#ifdef __amigaos4__
res = TimedDosRequesterTags(TDR_ImageType, TDRIMAGE_WARNING,
TDR_TitleString, messages_get("NetSurf"),
TDR_FormatString, utf8text,
TDR_GadgetString, utf8gadgets,
TDR_Window, win,
TAG_DONE);
#else
struct EasyStruct easyreq = {
sizeof(struct EasyStruct),
0,
messages_get("NetSurf"),
utf8text,
utf8gadgets,
};
res = EasyRequest(win, &easyreq, NULL);
#endif
if(utf8text) free(utf8text);
if(utf8gadgets) FreeVec(utf8gadgets);
return res;
}
static nserror gui_download_window_data(struct gui_download_window *dw,
const char *data, unsigned int size)
{
APTR va[3];
if(!dw) return NSERROR_SAVE_FAILED;
FWrite(dw->fh,data,1,size);
dw->downloaded = dw->downloaded + size;
va[0] = (APTR)dw->downloaded;
va[1] = (APTR)dw->size;
va[2] = 0;
if(dw->size)
{
RefreshSetGadgetAttrs((struct Gadget *)dw->objects[GID_STATUS], dw->win, NULL,
FUELGAUGE_Level, dw->downloaded,
GA_Text, messages_get("amiDownload"),
FUELGAUGE_VarArgs, va,
TAG_DONE);
}
else
{
RefreshSetGadgetAttrs((struct Gadget *)dw->objects[GID_STATUS], dw->win, NULL,
FUELGAUGE_Level, dw->downloaded,
GA_Text, messages_get("amiDownloadU"),
FUELGAUGE_VarArgs, va,
TAG_DONE);
}
return NSERROR_OK;
}
void translate_menu(wimp_menu *menu)
{
unsigned int i = 0;
const char *indirected_text;
/* We can't just blindly set something as indirected as if we use
the fallback messages text (ie the pointer we gave), we overwrite
this data when setting the pointer to the indirected text we
already had.
*/
indirected_text = messages_get(menu->title_data.text);
if (indirected_text != menu->title_data.text) {
menu->title_data.indirected_text.text = indirected_text;
menu->entries[0].menu_flags |= wimp_MENU_TITLE_INDIRECTED;
}
/* items */
do {
indirected_text = messages_get(menu->entries[i].data.text);
if (indirected_text != menu->entries[i].data.text) {
menu->entries[i].icon_flags |= wimp_ICON_INDIRECTED;
menu->entries[i].data.indirected_text.text = indirected_text;
menu->entries[i].data.indirected_text.validation = 0;
menu->entries[i].data.indirected_text.size = strlen(indirected_text) + 1;
}
i++;
} while ((menu->entries[i - 1].menu_flags & wimp_MENU_LAST) == 0);
}
/**
* Initialises the base nodes
*/
void ro_gui_global_history_initialise_nodes(void)
{
struct tm *full_time;
time_t t;
int weekday;
int i;
/* get the current time */
t = time(NULL);
if (t == -1)
return;
/* get the time at the start of today */
full_time = localtime(&t);
weekday = full_time->tm_wday;
full_time->tm_sec = 0;
full_time->tm_min = 0;
full_time->tm_hour = 0;
t = mktime(full_time);
if (t == -1)
return;
ro_gui_global_history_initialise_node(messages_get("DateToday"), t, 0);
if (weekday > 0)
ro_gui_global_history_initialise_node(
messages_get("DateYesterday"), t, -1);
for (i = 2; i <= weekday; i++)
ro_gui_global_history_initialise_node(NULL, t, -i);
ro_gui_global_history_initialise_node(messages_get("Date1Week"),
t, -weekday - 7);
ro_gui_global_history_initialise_node(messages_get("Date2Week"),
t, -weekday - 14);
ro_gui_global_history_initialise_node(messages_get("Date3Week"),
t, -weekday - 21);
}
void tree_update_URL_node(struct node *node, const char *url,
const struct url_data *data)
{
struct node_element *element;
char buffer[256];
assert(node);
element = tree_find_element(node, TREE_ELEMENT_URL);
if (!element)
return;
if (data) {
/* node is linked, update */
assert(!node->editable);
if (!data->title)
urldb_set_url_title(url, url);
if (!data->title)
return;
node->data.text = data->title;
} else {
/* node is not linked, find data */
assert(node->editable);
data = urldb_get_url_data(element->text);
if (!data)
return;
}
/* not implemented yet
if (element) {
sprintf(buffer, "small_%.3x", ro_content_filetype_from_type(data->type));
if (ro_gui_wimp_sprite_exists(buffer))
tree_set_node_sprite(node, buffer, buffer);
else
tree_set_node_sprite(node, "small_xxx", "small_xxx");
}
*/
element = tree_find_element(node, TREE_ELEMENT_LAST_VISIT);
if (element) {
snprintf(buffer, 256, (char *)messages_get("TreeLast"),
(data->last_visit > 0) ?
ctime((time_t *)&data->last_visit) :
(char *)messages_get("TreeUnknown"));
if (data->last_visit > 0)
buffer[strlen(buffer) - 1] = '\0';
free((void *)element->text);
element->text = (char *)strdup(buffer);
}
element = tree_find_element(node, TREE_ELEMENT_VISITS);
if (element) {
snprintf(buffer, 256, (char *)messages_get("TreeVisits"),
data->visits);
free((void *)element->text);
element->text = (char *)strdup(buffer);
}
}
/**
* Check that at least Homerton.Medium is available.
*/
static void nsfont_check_fonts(void)
{
char s[252];
font_f font;
os_error *error;
error = xfont_find_font("Homerton.Medium\\ELatin1",
160, 160, 0, 0, &font, 0, 0);
if (error) {
if (error->errnum == error_FILE_NOT_FOUND) {
xwimp_start_task("TaskWindow -wimpslot 200K -quit "
"<NetSurf$Dir>.FixFonts", 0);
die("FontBadInst");
} else {
LOG("xfont_find_font: 0x%x: %s", error->errnum, error->errmess);
snprintf(s, sizeof s, messages_get("FontError"),
error->errmess);
die(s);
}
}
error = xfont_lose_font(font);
if (error) {
LOG("xfont_lose_font: 0x%x: %s", error->errnum, error->errmess);
snprintf(s, sizeof s, messages_get("FontError"),
error->errmess);
die(s);
}
}
static bool nsico_convert(struct content *c)
{
nsico_content *ico = (nsico_content *) c;
struct bmp_image *bmp;
bmp_result res;
union content_msg_data msg_data;
const char *data;
unsigned long size;
char *title;
/* set the ico data */
data = content__get_source_data(c, &size);
/* analyse the ico */
res = ico_analyse(ico->ico, size, (unsigned char *) data);
switch (res) {
case BMP_OK:
break;
case BMP_INSUFFICIENT_MEMORY:
msg_data.error = messages_get("NoMemory");
content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
return false;
case BMP_INSUFFICIENT_DATA:
case BMP_DATA_ERROR:
msg_data.error = messages_get("BadICO");
content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
return false;
}
/* Store our content width, height and calculate size */
c->width = ico->ico->width;
c->height = ico->ico->height;
c->size += (ico->ico->width * ico->ico->height * 4) + 16 + 44;
/* set title text */
title = messages_get_buff("ICOTitle",
nsurl_access_leaf(llcache_handle_get_url(c->llcache)),
c->width, c->height);
if (title != NULL) {
content__set_title(c, title);
free(title);
}
/* select largest icon to ensure one can be selected */
bmp = ico_find(ico->ico, 255, 255);
if (bmp == NULL) {
/* return error */
LOG("Failed to select icon");
return false;
}
content_set_ready(c);
content_set_done(c);
/* Done: update status bar */
content_set_status(c, "");
return true;
}
static void ami_print_ui_setup(void)
{
gadlab[PGID_PRINTER] = (char *)ami_utf8_easy((char *)messages_get("Printer"));
gadlab[PGID_SCALE] = (char *)ami_utf8_easy((char *)messages_get("Scale"));
gadlab[PGID_COPIES] = (char *)ami_utf8_easy((char *)messages_get("Copies"));
gadlab[PGID_PRINT] = (char *)ami_utf8_easy((char *)messages_get("ObjPrint"));
gadlab[PGID_CANCEL] = (char *)ami_utf8_easy((char *)messages_get("Cancel"));
}
void warn_user(const char *warning, const char *detail)
{
size_t len = 1 + ((warning != NULL) ? strlen(messages_get(warning)) :
0) + ((detail != 0) ? strlen(detail) : 0);
char message[len];
snprintf(message, len, messages_get(warning), detail);
printf("%s\n", message);
}
void warn_user(const char *warning, const char *detail)
{
size_t len = 1 + ((warning != NULL) ? strlen(messages_get(warning)) :
0) + ((detail != 0) ? strlen(detail) : 0);
char message[len];
snprintf(message, len, messages_get(warning), detail);
MessageBox(NULL, message, "Warning", MB_ICONWARNING);
}
static bool nsbmp_convert(struct content *c)
{
nsbmp_content *bmp = (nsbmp_content *) c;
bmp_result res;
union content_msg_data msg_data;
uint32_t swidth;
const char *data;
unsigned long size;
char *title;
/* set the bmp data */
data = content__get_source_data(c, &size);
/* analyse the BMP */
res = bmp_analyse(bmp->bmp, size, (unsigned char *) data);
switch (res) {
case BMP_OK:
break;
case BMP_INSUFFICIENT_MEMORY:
msg_data.error = messages_get("NoMemory");
content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
return false;
case BMP_INSUFFICIENT_DATA:
case BMP_DATA_ERROR:
msg_data.error = messages_get("BadBMP");
content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
return false;
}
/* Store our content width and description */
c->width = bmp->bmp->width;
c->height = bmp->bmp->height;
swidth = bmp->bmp->bitmap_callbacks.bitmap_get_bpp(bmp->bmp->bitmap) *
bmp->bmp->width;
c->size += (swidth * bmp->bmp->height) + 16 + 44;
/* set title text */
title = messages_get_buff("BMPTitle",
nsurl_access_leaf(llcache_handle_get_url(c->llcache)),
c->width, c->height);
if (title != NULL) {
content__set_title(c, title);
free(title);
}
/* exit as a success */
bmp->bitmap = bmp->bmp->bitmap;
guit->bitmap->modified(bmp->bitmap);
content_set_ready(c);
content_set_done(c);
/* Done: update status bar */
content_set_status(c, "");
return true;
}
END_HANDLER
BUTTON_CLICKED(buttonaddtheme)
{
char *filename, *directory;
size_t len;
GtkWidget *fc = gtk_file_chooser_dialog_new(
messages_get("gtkAddThemeTitle"),
GTK_WINDOW(wndPreferences),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
len = SLEN("themes") + strlen(res_dir_location) + 1;
char themesfolder[len];
snprintf(themesfolder, len, "%sthemes", res_dir_location);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fc),
themesfolder);
gint res = gtk_dialog_run(GTK_DIALOG(fc));
if (res == GTK_RESPONSE_ACCEPT) {
filename = gtk_file_chooser_get_current_folder(
GTK_FILE_CHOOSER(fc));
if (strcmp(filename, themesfolder) != 0) {
directory = strrchr(filename, '/');
*directory = '\0';
if (strcmp(filename, themesfolder) != 0) {
warn_user(messages_get(
"gtkThemeFolderInstructions"),
0);
gtk_widget_destroy(GTK_WIDGET(fc));
if (filename != NULL)
g_free(filename);
return FALSE;
} else {
directory++;
}
} else {
if (filename != NULL)
g_free(filename);
filename = gtk_file_chooser_get_filename(
GTK_FILE_CHOOSER(fc));
if (strcmp(filename, themesfolder) == 0) {
warn_user(messages_get("gtkThemeFolderSub"),
0);
gtk_widget_destroy(GTK_WIDGET(fc));
g_free(filename);
return FALSE;
}
directory = strrchr(filename, '/') + 1;
}
gtk_widget_destroy(GTK_WIDGET(fc));
nsgtk_theme_add(directory);
if (filename != NULL)
g_free(filename);
}
}
void die(const char *error)
{
TimedDosRequesterTags(TDR_ImageType,TDRIMAGE_ERROR,
TDR_TitleString,messages_get("NetSurf"),
TDR_GadgetString,messages_get("OK"),
// TDR_CharSet,106,
TDR_FormatString,"%s",
TDR_Arg1,error,
TAG_DONE);
exit(1);
}
bool nsico_convert(struct content *c)
{
struct bmp_image *bmp;
bmp_result res;
ico_collection *ico;
union content_msg_data msg_data;
const char *data;
unsigned long size;
char title[100];
/* set the ico data */
ico = c->data.ico.ico;
data = content__get_source_data(c, &size);
/* analyse the ico */
res = ico_analyse(ico, size, (unsigned char *) data);
switch (res) {
case BMP_OK:
break;
case BMP_INSUFFICIENT_MEMORY:
msg_data.error = messages_get("NoMemory");
content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
return false;
case BMP_INSUFFICIENT_DATA:
case BMP_DATA_ERROR:
msg_data.error = messages_get("BadICO");
content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
return false;
}
/* Store our content width and description */
c->width = ico->width;
c->height = ico->height;
snprintf(title, sizeof(title), messages_get("ICOTitle"),
c->width, c->height, size);
content__set_title(c, title);
c->size += (ico->width * ico->height * 4) + 16 + 44;
/* exit as a success */
bmp = ico_find(c->data.ico.ico, 255, 255);
assert(bmp);
c->bitmap = bmp->bitmap;
bitmap_modified(c->bitmap);
c->status = CONTENT_STATUS_DONE;
/* Done: update status bar */
content_set_status(c, "");
return true;
}
void ro_gui_save_open(int save_type, int x, int y)
{
char icon_buf[20];
const char *icon = icon_buf;
os_error *error;
gui_save_current_type = save_type;
if (save_type == SAVE_THEME) {
if (theme_filename == NULL) {
theme_filename = malloc(6);
if (!theme_filename) {
LOG(("No memory for malloc()"));
warn_user("NoMemory", 0);
return;
}
sprintf(theme_filename, "Theme");
}
gui_save_filetype = 0xffd;
ro_gui_set_window_title(dialog_saveas, messages_get("SaveTitle"));
ro_gui_set_icon_string(dialog_saveas, ICON_SAVE_PATH, theme_filename);
reset_filename = theme_filename;
} else {
if (sprite_filename == NULL) {
sprite_filename = malloc(8);
if (!sprite_filename) {
LOG(("No memory for malloc()"));
warn_user("NoMemory", 0);
return;
}
sprintf(sprite_filename, "Sprites");
}
gui_save_filetype = 0xff9;
ro_gui_set_window_title(dialog_saveas, messages_get("ExportTitle"));
ro_gui_set_icon_string(dialog_saveas, ICON_SAVE_PATH, sprite_filename);
reset_filename = sprite_filename;
}
/* icon */
sprintf(icon_buf, "file_%.3x", gui_save_filetype);
ro_gui_set_icon_string(dialog_saveas, ICON_SAVE_ICON, icon);
/* open sub menu or persistent dialog */
error = xwimp_create_sub_menu((wimp_menu *) dialog_saveas,
x, y);
if (error) {
LOG(("xwimp_create_sub_menu: 0x%x: %s",
error->errnum, error->errmess));
warn_user("MenuError", error->errmess);
}
}
static void content_update_status(struct content *c)
{
if (c->status == CONTENT_STATUS_LOADING ||
c->status == CONTENT_STATUS_READY) {
/* Not done yet */
snprintf(c->status_message, sizeof (c->status_message),
"%s%s%s", messages_get("Fetching"),
c->sub_status ? ", " : " ", c->sub_status);
} else {
unsigned int time = c->time;
snprintf(c->status_message, sizeof (c->status_message),
"%s (%.1fs)", messages_get("Done"),
(float) time / 100);
}
}
static void __CDECL menu_open_file(short item, short title, void *data)
{
LOG(("%s", __FUNCTION__));
const char * filename = file_select(messages_get("OpenFile"), "");
if( filename != NULL ){
char * urltxt = local_file_to_url( filename );
if( urltxt ){
nsurl *url;
nserror error;
error = nsurl_create(urltxt, &url);
if (error == NSERROR_OK) {
error = browser_window_create(BROWSER_WINDOW_VERIFIABLE |
BROWSER_WINDOW_HISTORY,
url,
NULL,
NULL,
NULL);
nsurl_unref(url);
}
if (error != NSERROR_OK) {
warn_user(messages_get_errorcode(error), 0);
}
free( urltxt );
}
}
}
/**
* Generate menubar menus.
*
* Generate the main menu structure and attach it to a menubar widget.
*/
struct nsgtk_bar_submenu *nsgtk_menu_bar_create(GtkMenuShell *menubar, GtkAccelGroup *group)
{
;
struct nsgtk_bar_submenu *nmenu;
nmenu = malloc(sizeof(struct nsgtk_bar_submenu));
if (nmenu == NULL) {
warn_user(messages_get("NoMemory"), 0);
return NULL;
}
nmenu->bar_menu = GTK_MENU_BAR(menubar);
nmenu->file_submenu = nsgtk_menu_file_submenu(group);
ATTACH_PARENT(menubar, gtkFile, nmenu->file_submenu->file, group);
nmenu->edit_submenu = nsgtk_menu_edit_submenu(group);
ATTACH_PARENT(menubar, gtkEdit, nmenu->edit_submenu->edit, group);
nmenu->view_submenu = nsgtk_menu_view_submenu(group);
ATTACH_PARENT(menubar, gtkView, nmenu->view_submenu->view, group);
nmenu->nav_submenu = nsgtk_menu_nav_submenu(group);
ATTACH_PARENT(menubar, gtkNavigate, nmenu->nav_submenu->nav, group);
nmenu->help_submenu = nsgtk_menu_help_submenu(group);
ATTACH_PARENT(menubar, gtkHelp, nmenu->help_submenu->help, group);
return nmenu;
}
static void nsgtk_options_theme_combo(void) {
/* populate theme combo from themelist file */
GtkBox *box = GTK_BOX(glade_xml_get_widget(gladeFile, "themehbox"));
char buf[50];
combotheme = gtk_combo_box_new_text();
size_t len = SLEN("themelist") + strlen(res_dir_location) + 1;
char themefile[len];
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';
gtk_combo_box_append_text(GTK_COMBO_BOX(combotheme), buf);
}
fclose(fp);
gtk_combo_box_set_active(GTK_COMBO_BOX(combotheme),
option_current_theme);
gtk_box_pack_start(box, combotheme, FALSE, TRUE, 0);
gtk_widget_show(combotheme);
}
void atari_global_history_init(void)
{
if (atari_global_history.init == false) {
if( atari_global_history.window == NULL ) {
int flags = ATARI_TREEVIEW_WIDGETS;
short handle = -1;
OBJECT * tree = gemtk_obj_get_tree(TOOLBAR_HISTORY);
assert( tree );
handle = wind_create(flags, 0, 0, desk_area.g_w, desk_area.g_h);
atari_global_history.window = gemtk_wm_add(handle, GEMTK_WM_FLAG_DEFAULTS, NULL);
if( atari_global_history.window == NULL ) {
gemtk_msg_box_show(GEMTK_MSG_BOX_ALERT,
"Failed to allocate History");
return;
}
wind_set_str(handle, WF_NAME, (char*)messages_get("History"));
gemtk_wm_set_toolbar(atari_global_history.window, tree, 0, 0);
gemtk_wm_unlink(atari_global_history.window);
atari_global_history.tv = atari_treeview_create(
atari_global_history.window,
&atari_global_history_treeview_callbacks,
NULL, flags);
if (atari_global_history.tv == NULL) {
/* handle it properly, clean up previous allocs */
NSLOG(netsurf, INFO,
"Failed to allocate treeview");
return;
}
}
}
atari_global_history.init = true;
}
static void ami_menu_item_arexx_execute(struct Hook *hook, APTR window, struct IntuiMessage *msg)
{
char *temp;
struct gui_window_2 *gwin;
GetAttr(WINDOW_UserData, (Object *)window, (ULONG *)&gwin);
if(AslRequestTags(filereq,
ASLFR_Window, gwin->win,
ASLFR_SleepWindow, TRUE,
ASLFR_TitleText, messages_get("NetSurf"),
ASLFR_Screen, scrn,
ASLFR_DoSaveMode, FALSE,
ASLFR_InitialDrawer, nsoption_charp(arexx_dir),
ASLFR_InitialPattern, "#?.nsrx",
TAG_DONE))
{
if(temp = AllocVecTagList(1024, NULL))
{
strlcpy(temp, filereq->fr_Drawer, 1024);
AddPart(temp, filereq->fr_File, 1024);
ami_arexx_execute(temp);
FreeVec(temp);
}
}
}
static GtkImage *
nsgtk_theme_searchimage_default(nsgtk_search_buttons tbbutton,
GtkIconSize iconsize)
{
char *imagefile;
GtkImage *image;
switch(tbbutton) {
case (SEARCH_BACK_BUTTON):
return GTK_IMAGE(gtk_image_new_from_stock("gtk-go-back", iconsize));
case (SEARCH_FORWARD_BUTTON):
return GTK_IMAGE(gtk_image_new_from_stock("gtk-go-forward",
iconsize));
case (SEARCH_CLOSE_BUTTON):
return GTK_IMAGE(gtk_image_new_from_stock("gtk-close", iconsize));
default: {
size_t len = SLEN("themes/Alpha.png") +
strlen(res_dir_location) + 1;
imagefile = malloc(len);
if (imagefile == NULL) {
warn_user(messages_get("NoMemory"), 0);
return NULL;
}
snprintf(imagefile, len, "%sthemes/Alpha.png",
res_dir_location);
image = GTK_IMAGE(
gtk_image_new_from_file(imagefile));
free(imagefile);
return image;
}
}
}
static bool theme_install_read(const char *data, unsigned long len)
{
char *filename, *newfilename;
size_t namelen;
int handle = g_file_open_tmp("nsgtkthemeXXXXXX", &filename, NULL);
if (handle == -1) {
warn_user(messages_get("gtkFileError"),
"temporary theme file");
return false;
}
ssize_t written = write(handle, data, len);
close(handle);
if ((unsigned)written != len)
return false;
/* get name of theme; set as dirname */
namelen = SLEN("themes/") + strlen(res_dir_location) + 1;
char dirname[namelen];
snprintf(dirname, namelen, "%sthemes/", res_dir_location);
/* save individual files in theme */
newfilename = container_extract_theme(filename, dirname);
g_free(filename);
if (newfilename == NULL)
return false;
nsgtk_theme_add(newfilename);
free(newfilename);
return true;
}
static void ami_menu_alloc_item(struct gui_window_2 *gwin, int num, UBYTE type,
const char *label, char key, char *icon, void *func, void *hookdata)
{
char menu_icon[1024];
gwin->menutype[num] = type;
if((label == NM_BARLABEL) || (strcmp(label, "--") == 0)) {
gwin->menulab[num] = NM_BARLABEL;
} else {
if((num >= AMI_MENU_HOTLIST) && (num <= AMI_MENU_HOTLIST_MAX)) {
gwin->menulab[num] = ami_utf8_easy(label);
} else if((num >= AMI_MENU_AREXX) && (num <= AMI_MENU_AREXX_MAX)) {
gwin->menulab[num] = strdup(label);
} else {
gwin->menulab[num] = ami_utf8_easy(messages_get(label));
}
}
gwin->menuicon[num] = NULL;
if(key) gwin->menukey[num] = key;
if(func) gwin->menu_hook[num].h_Entry = (HOOKFUNC)func;
if(hookdata) gwin->menu_hook[num].h_Data = hookdata;
if(icon) {
if(ami_locate_resource(menu_icon, icon) == true)
gwin->menuicon[num] = (char *)strdup(menu_icon);
}
}
END_HANDLER
COMBO_CHANGED(comboSearch, search_provider)
{
nsgtk_scaffolding *current = scaf_list;
char *name;
/* refresh web search prefs from file */
search_web_provider_details(nsoption_charp(search_provider));
/* retrieve ico */
search_web_retrieve_ico(false);
/* callback may handle changing gui */
if (search_web_ico() != NULL)
gui_window_set_search_ico(search_web_ico());
/* set entry */
name = search_web_provider_name();
if (name == NULL) {
warn_user(messages_get("NoMemory"), 0);
continue;
}
char content[strlen(name) + SLEN("Search ") + 1];
sprintf(content, "Search %s", name);
free(name);
while (current) {
nsgtk_scaffolding_set_websearch(current, content);
current = nsgtk_scaffolding_iterate(current);
}
}
