int meta_match_file_mask(meta *m, io_file_mask *ifm, io_file_index file) { int retval = 1; io_file *ifile; ifile = &m->files.files_val[file]; if( ifm->id[0] ) { if( ifm->mask_flags & IO_FILE_MASK_FILE_PART ) { if( ((ifm->mask_flags & IO_FILE_MASK_HAS_ID) && strcmp(ifm->id, file_part(ifile->id))) || (!(ifm->mask_flags & IO_FILE_MASK_HAS_ID) && !strcmp(ifm->id, file_part(ifile->id))) ) retval = 0; } else { if( ((ifm->mask_flags & IO_FILE_MASK_HAS_ID) && strcmp(ifm->id, ifile->id)) || (!(ifm->mask_flags & IO_FILE_MASK_HAS_ID) && !strcmp(ifm->id, ifile->id)) ) retval = 0; } } if( (ifile->flags & ifm->set_flags) != ifm->set_flags ) retval = 0; if( ifile->flags & ifm->unset_flags ) retval = 0; return( retval ); }
buffer *get_buffer_named(const char *p) { if (!p) return NULL; p = file_part(p); for(buffer *b = (buffer *)buffers.head; b->b_node.next; b = (buffer *)b->b_node.next) if (b->filename && !strcmp(file_part(b->filename), p)) return b; return NULL; }
char *complete_filename(const char *start_prefix) { /* This might be NULL if the current directory has been unlinked, or it is not readable. in that case, we end up moving to the completion directory. */ char * const cur_dir_name = ne_getcwd(CUR_DIR_MAX_SIZE); char * const dir_name = str_dup(start_prefix); if (dir_name) { char * const p = (char *)file_part(dir_name); *p = 0; if (p != dir_name && chdir(tilde_expand(dir_name)) == -1) { free(dir_name); return NULL; } } start_prefix = file_part(start_prefix); bool is_dir, unique = true; char *cur_prefix = NULL; DIR * const d = opendir(CURDIR); if (d) { for(struct dirent * de; !stop && (de = readdir(d)); ) { if (is_prefix(start_prefix, de->d_name)) if (cur_prefix) { cur_prefix[max_prefix(cur_prefix, de->d_name)] = 0; unique = false; } else { cur_prefix = str_dup(de->d_name); is_dir = is_directory(de->d_name); } } closedir(d); } char * result = NULL; if (cur_prefix) { result = malloc(strlen(dir_name) + strlen(cur_prefix) + 2); strcat(strcat(strcpy(result, dir_name), cur_prefix), unique && is_dir ? "/" : ""); } if (cur_dir_name != NULL) { chdir(cur_dir_name); free(cur_dir_name); } free(dir_name); free(cur_prefix); return result; }
int plugin_kill (char *name, int by_filename) { GSList *list; hexchat_plugin *pl; list = plugin_list; while (list) { pl = list->data; /* static-plugins (plugin-timer.c) have a NULL filename */ if ((by_filename && pl->filename && g_ascii_strcasecmp (name, pl->filename) == 0) || (by_filename && pl->filename && g_ascii_strcasecmp (name, file_part (pl->filename)) == 0) || (!by_filename && g_ascii_strcasecmp (name, pl->name) == 0)) { /* statically linked plugins have a NULL filename */ if (pl->filename != NULL && !pl->fake) { if (plugin_free (pl, TRUE, TRUE)) return 1; return 2; } } list = list->next; } return 0; }
int plugin_kill(char *name, int by_filename) { GSList *list; xchat_plugin *pl; list = plugin_list; while (list) { pl = (xchat_plugin*)list->data; // static-plugins (plugin-timer.c) have a nullptr filename if ((by_filename && pl->filename && strcasecmp(name, pl->filename) == 0) || (by_filename && pl->filename && strcasecmp(name, file_part(pl->filename)) == 0) || (!by_filename && strcasecmp(name, pl->name) == 0)) { // statically linked plugins have a nullptr filename if (pl->filename != nullptr && !pl->fake) { if (plugin_free(pl, TRUE, TRUE)) return 1; return 2; } } list = list->next; } return 0; }
void fe_pluginlist_update (void) { hexchat_plugin *pl; GSList *list; GtkTreeView *view; GtkListStore *store; GtkTreeIter iter; if (!plugin_window) return; view = g_object_get_data (G_OBJECT (plugin_window), "view"); store = GTK_LIST_STORE (gtk_tree_view_get_model (view)); gtk_list_store_clear (store); list = plugin_list; while (list) { pl = list->data; if (pl->version[0] != 0) { gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, NAME_COLUMN, pl->name, VERSION_COLUMN, pl->version, FILE_COLUMN, file_part (pl->filename), DESC_COLUMN, pl->desc, -1); } list = list->next; } }
GModule * module_load (char *filename) { void *handle; char *filepart; char *pluginpath; /* get the filename without path */ filepart = file_part (filename); /* load the plugin */ if (!g_ascii_strcasecmp (filepart, filename)) { /* no path specified, it's just the filename, try to load from config dir */ pluginpath = g_build_filename (get_xdir (), "addons", filename, NULL); handle = g_module_open (pluginpath, 0); g_free (pluginpath); } else { /* try to load with absolute path */ handle = g_module_open (filename, 0); } return handle; }
static void dcc_prepare_row_recv (struct DCC *dcc, GtkListStore *store, GtkTreeIter *iter, gboolean update_only) { static char size[16], pos[16], kbs[16], perc[14], eta[16]; float per; int to_go; if (!pix_dn) pix_dn = gtk_widget_render_icon (dccfwin.window, "gtk-go-down", GTK_ICON_SIZE_MENU, NULL); proper_unit (dcc->size, size, sizeof (size)); if (dcc->dccstat == STAT_QUEUED) proper_unit (dcc->resumable, pos, sizeof (pos)); else proper_unit (dcc->pos, pos, sizeof (pos)); snprintf (kbs, sizeof (kbs), "%.1f", ((float)dcc->cps) / 1024); /* percentage recv'ed */ per = (float) ((dcc->pos * 100.00) / dcc->size); snprintf (perc, sizeof (perc), "%.0f%%", per); if (dcc->cps != 0) { to_go = (dcc->size - dcc->pos) / dcc->cps; snprintf (eta, sizeof (eta), "%.2d:%.2d:%.2d", to_go / 3600, (to_go / 60) % 60, to_go % 60); } else strcpy (eta, "--:--:--"); if (update_only) gtk_list_store_set (store, iter, COL_STATUS, _(dccstat[dcc->dccstat].name), COL_POS, pos, COL_PERC, perc, COL_SPEED, kbs, COL_ETA, eta, COL_COLOR, dccstat[dcc->dccstat].color == 1 ? NULL : colors + dccstat[dcc->dccstat].color, -1); else gtk_list_store_set (store, iter, COL_TYPE, pix_dn, COL_STATUS, _(dccstat[dcc->dccstat].name), COL_FILE, file_part (dcc->file), COL_SIZE, size, COL_POS, pos, COL_PERC, perc, COL_SPEED, kbs, COL_ETA, eta, COL_NICK, dcc->nick, COL_DCC, dcc, COL_COLOR, dccstat[dcc->dccstat].color == 1 ? NULL : colors + dccstat[dcc->dccstat].color, -1); }
void signal_printer_dcc_send_request(gpointer *params) { struct session *sess = params[0]; struct DCC *dcc = params[1]; gchar *to = params[2]; session_print_format(sess, "dcc send offer", file_part(dcc->file), to, dcc->file); }
void signal_printer_dcc_file_resume(gpointer *params) { struct session *sess = params[0]; gchar *nick = params[1]; struct DCC *dcc = params[2]; gchar *tbuf = params[3]; session_print_format(sess, "dcc resume request", nick, file_part (dcc->file), tbuf); }
void signal_printer_dcc_stoned(gpointer *params) { struct DCC *dcc = params[0]; server *serv = dcc->serv; gchar *type = g_strdup(dcctypes[dcc->type]); session_print_format(serv->front_session, "dcc timeout", type, file_part(dcc->file), dcc->nick); dcc_close(dcc, STAT_ABORTED, FALSE); }
void signal_printer_dcc_send_failed(gpointer *params) { struct DCC *dcc = params[0]; server *serv = dcc->serv; gchar *error = params[1]; session_print_format(serv->front_session, "dcc send failed", file_part(dcc->file), dcc->nick, error); dcc_close (dcc, STAT_FAILED, FALSE); }
static void plugin_auto_load_cb(char *filename) { char *pMsg; #ifndef WIN32 /* black listed */ if (!strcmp(file_part(filename), "dbus.so")) return; #endif pMsg = plugin_load(ps, filename, nullptr); if (pMsg) { PrintTextf(ps, "AutoLoad failed for: %s\n", filename); PrintText(ps, pMsg); } }
void signal_printer_dcc_send_complete(gpointer *params) { struct DCC *dcc = params[0]; server *serv = dcc->serv; gchar *buf; /* force 100% ack for >4 GB */ dcc->ack = dcc->size; dcc_close (dcc, STAT_DONE, FALSE); dcc_calc_average_cps (dcc); buf = g_strdup_printf("%d", dcc->cps); session_print_format(serv->front_session, "dcc send complete", file_part(dcc->file), dcc->nick, buf); g_free(buf); }
char * plugin_load (session *sess, char *filename, char *arg) { void *handle; char *filepart; hexchat_init_func *init_func; hexchat_deinit_func *deinit_func; char *pluginpath; /* get the filename without path */ filepart = file_part (filename); /* load the plugin */ if (!g_ascii_strcasecmp (filepart, filename)) { /* no path specified, it's just the filename, try to load from config dir */ pluginpath = g_build_filename (get_xdir (), "addons", filename, NULL); handle = g_module_open (pluginpath, 0); g_free (pluginpath); } else { /* try to load with absolute path */ handle = g_module_open (filename, 0); } if (handle == NULL) return (char *)g_module_error (); /* find the init routine hexchat_plugin_init */ if (!g_module_symbol (handle, "hexchat_plugin_init", (gpointer *)&init_func)) { g_module_close (handle); return _("No hexchat_plugin_init symbol; is this really a HexChat plugin?"); } /* find the plugin's deinit routine, if any */ if (!g_module_symbol (handle, "hexchat_plugin_deinit", (gpointer *)&deinit_func)) deinit_func = NULL; /* add it to our linked list */ plugin_add (sess, filename, handle, init_func, deinit_func, arg, FALSE); return NULL; }
io_file_index meta_find_file(meta *m, const char *id, int flags, int absolute_path) { unsigned int lpc; io_file_index retval = -1; io_file *iofile; for( lpc = 0; (lpc < m->files.files_len) && (retval == -1); lpc++ ) { iofile = &m->files.files_val[lpc]; if( (!id || !strcmp((absolute_path ? iofile->id : file_part(iofile->id)), id)) && (!flags || (iofile->flags & flags)) ) { retval = lpc; } } return( retval ); }
static void dcc_abort (struct DCC *dcc) { if (dcc) { switch (dcc->dccstat) { case STAT_QUEUED: case STAT_CONNECTING: case STAT_ACTIVE: dcc_close (dcc, STAT_ABORTED, FALSE); EMIT_SIGNAL (XP_TE_DCCABORT, dcc->serv->front_session, dcctypes[(int) dcc->type], file_part (dcc->file), dcc->nick, NULL, 0); break; default: dcc_close (dcc, 0, TRUE); } } }
int plugin_reload (session *sess, char *name, int by_filename) { GSList *list; char *filename; char *ret; hexchat_plugin *pl; list = plugin_list; while (list) { pl = list->data; /* static-plugins (plugin-timer.c) have a NULL filename */ if ((by_filename && pl->filename && g_ascii_strcasecmp (name, pl->filename) == 0) || (by_filename && pl->filename && g_ascii_strcasecmp (name, file_part (pl->filename)) == 0) || (!by_filename && g_ascii_strcasecmp (name, pl->name) == 0)) { /* statically linked plugins have a NULL filename */ if (pl->filename != NULL && !pl->fake) { filename = g_strdup (pl->filename); plugin_free (pl, TRUE, FALSE); ret = plugin_load (sess, filename, NULL); g_free (filename); if (ret == NULL) return 1; else return 0; } else return 2; } list = list->next; } return 0; }
char *request_files(const char * const filename, int use_prefix) { int i, num_entries, name_len, max_name_len, total_len, next_dir, is_dir, entries_alloc_size = DEF_ENTRIES_ALLOC_SIZE, names_alloc_size = DEF_NAMES_ALLOC_SIZE; char *dir_name, **entries = NULL, *names = NULL, *cur_dir_name, *result = NULL, *p; DIR *d; struct dirent *de; if (!(cur_dir_name = ne_getcwd(CUR_DIR_MAX_SIZE))) return NULL; if (dir_name = str_dup(filename)) { i = 0; if ((p = (char *)file_part(dir_name)) != dir_name) { *p = 0; i = chdir(tilde_expand(dir_name)); } free(dir_name); if (i == -1) return NULL; } if (entries = malloc(sizeof(char *) * entries_alloc_size)) { if (names = malloc(sizeof(char) * names_alloc_size)) { do { next_dir = FALSE; if (d = opendir(CURDIR)) { num_entries = max_name_len = total_len = 0; stop = FALSE; while(!stop && (de = readdir(d))) { is_dir = is_directory(de->d_name); if (use_prefix && !is_prefix(file_part(filename), de->d_name)) continue; name_len = strlen(de->d_name) + is_dir + 1; if (name_len > max_name_len) max_name_len = name_len; if (total_len + name_len > names_alloc_size) { char *t; t = realloc(names, sizeof(char) * (names_alloc_size = names_alloc_size * 2 + name_len)); if (!t) break; names = t; /* Now adjust the entries to point to the newly reallocated strings */ entries[0] = names; for (i = 1; i < num_entries; i++) entries[i] = entries[i - 1] + strlen(entries[i - 1]) + 1; } if (num_entries >= entries_alloc_size) { char **t; t = realloc(entries, sizeof(char *) * (entries_alloc_size *= 2)); if (!t) break; entries = t; } strcpy(entries[num_entries] = names + total_len, de->d_name); if (is_dir) strcpy(names + total_len + name_len - 2, "/"); total_len += name_len; num_entries++; } if (num_entries) { qsort(entries, num_entries, sizeof(char *), filenamecmpp); if ((i = request_strings((const char * const *)entries, num_entries, 0, max_name_len, '/')) != ERROR) { p = entries[i >= 0 ? i : -i - 2]; if (p[strlen(p) - 1] == '/' && i >= 0) { p[strlen(p) - 1] = 0; if (chdir(p)) alert(); else use_prefix = FALSE; next_dir = TRUE; } else { result = ne_getcwd(CUR_DIR_MAX_SIZE + strlen(p) + 2); if (strcmp(result, "/")) strcat(result, "/"); strcat(result, p); if (i < 0) { memmove(result + 1, result, strlen(result) + 1); result[0] = 0; } } } } closedir(d); } else alert(); } while(next_dir); free(names); } free(entries); } chdir(cur_dir_name); free(cur_dir_name); return result; }
char * plugin_load (session *sess, char *filename, char *arg) { void *handle; xchat_init_func *init_func; xchat_deinit_func *deinit_func; #ifdef USE_GMODULE /* load the plugin */ handle = g_module_open (filename, 0); if (handle == NULL) return (char *)g_module_error (); /* find the init routine xchat_plugin_init */ if (!g_module_symbol (handle, "xchat_plugin_init", (gpointer *)&init_func)) { g_module_close (handle); return _("No xchat_plugin_init symbol; is this really an xchat plugin?"); } /* find the plugin's deinit routine, if any */ if (!g_module_symbol (handle, "xchat_plugin_deinit", (gpointer *)&deinit_func)) deinit_func = NULL; #else char *error; char *filepart; /* OpenBSD lacks this! */ #ifndef RTLD_GLOBAL #define RTLD_GLOBAL 0 #endif #ifndef RTLD_NOW #define RTLD_NOW 0 #endif /* get the filename without path */ filepart = file_part (filename); /* load the plugin */ if (filepart && /* xsys draws in libgtk-1.2, causing crashes, so force RTLD_LOCAL */ (strstr (filepart, "local") || strncmp (filepart, "libxsys-1", 9) == 0) ) handle = dlopen (filename, RTLD_NOW); else handle = dlopen (filename, RTLD_GLOBAL | RTLD_NOW); if (handle == NULL) return (char *)dlerror (); dlerror (); /* Clear any existing error */ /* find the init routine xchat_plugin_init */ init_func = dlsym (handle, "xchat_plugin_init"); error = (char *)dlerror (); if (error != NULL) { dlclose (handle); return _("No xchat_plugin_init symbol; is this really an xchat plugin?"); } /* find the plugin's deinit routine, if any */ deinit_func = dlsym (handle, "xchat_plugin_deinit"); error = (char *)dlerror (); #endif /* add it to our linked list */ plugin_add (sess, filename, handle, init_func, deinit_func, arg, FALSE); return NULL; }
char* plugin_load(session *sess, char *filename, char *arg) { void *handle; xchat_init_func *init_func; xchat_deinit_func *deinit_func; #ifdef USE_GMODULE // load the plugin handle = g_module_open(filename, (GModuleFlags)0); if (handle == nullptr) return (char*)g_module_error(); // find the init routine xchat_plugin_init if (!g_module_symbol((GModule*)handle, "xchat_plugin_init", (gpointer*)&init_func)) { g_module_close((GModule*)handle); return _("No xchat_plugin_init symbol; is this really an xchat plugin?"); } // find the plugin's deinit routine, if any if (!g_module_symbol((GModule*)handle, "xchat_plugin_deinit", (gpointer*)&deinit_func)) deinit_func = nullptr; #else char *error; char *filepart; // OpenBSD lacks this! #ifndef RTLD_GLOBAL #define RTLD_GLOBAL 0 #endif #ifndef RTLD_NOW #define RTLD_NOW 0 #endif // get the filename without path filepart = file_part(filename); // load the plugin if (filepart && // xsys draws in libgtk-1.2, causing crashes, so force RTLD_LOCAL (strstr(filepart, "local") || strncmp (filepart, "libxsys-1", 9) == 0)) handle = dlopen(filename, RTLD_NOW); else handle = dlopen(filename, RTLD_GLOBAL | RTLD_NOW); if (handle == nullptr) return (char*)dlerror(); dlerror(); // Clear any existing error // find the init routine xchat_plugin_init init_func = (xif)dlsym(handle, "xchat_plugin_init"); error = (char*)dlerror(); if (error != nullptr) { dlclose(handle); return _("No xchat_plugin_init symbol; is this really an xchat plugin?"); } // find the plugin's deinit routine, if any deinit_func = (xdf)dlsym(handle, "xchat_plugin_deinit"); error = (char*)dlerror(); #endif // add it to our linked list plugin_add(sess, filename, handle, (void*)init_func, (void*)deinit_func, arg, FALSE); return nullptr; }
char *request_files(const char * const filename, bool use_prefix) { char * const cur_dir_name = ne_getcwd(CUR_DIR_MAX_SIZE); if (!cur_dir_name) return NULL; char * const dir_name = str_dup(filename); if (dir_name) { int result = 0; char * const p = (char *)file_part(dir_name); if (p != dir_name) { *p = 0; result = chdir(tilde_expand(dir_name)); } free(dir_name); if (result == -1) return NULL; } req_list rl; bool next_dir; char *result = NULL; do { next_dir = false; if (req_list_init(&rl, filenamecmp, true, false, '/') != OK) break; DIR * const d = opendir(CURDIR); if (d) { stop = false; for(struct dirent * de; !stop && (de = readdir(d)); ) { const bool is_dir = is_directory(de->d_name); if (use_prefix && !is_prefix(file_part(filename), de->d_name)) continue; if (!req_list_add(&rl, de->d_name, is_dir)) break; } req_list_finalize(&rl); if (rl.cur_entries) { /* qsort(rl.entries, rl.cur_entries, sizeof(char *), filenamecmpp); */ const int t = request_strings(&rl, 0); if (t != ERROR) { char * const p = rl.entries[t >= 0 ? t : -t - 2]; if (p[strlen(p) - 1] == '/' && t >= 0) { p[strlen(p) - 1] = 0; if (chdir(p)) alert(); else use_prefix = false; next_dir = true; } else { result = ne_getcwd(CUR_DIR_MAX_SIZE + strlen(p) + 2); if (strcmp(result, "/")) strcat(result, "/"); strcat(result, p); if (t < 0) { memmove(result + 1, result, strlen(result) + 1); result[0] = 0; } } } } closedir(d); } else alert(); req_list_free(&rl); } while(next_dir); chdir(cur_dir_name); free(cur_dir_name); return result; }
void gtkutil_file_req (const char *title, void *callback, void *userdata, char *filter, char *extensions, int flags) { struct file_req *freq; GtkWidget *dialog; GtkFileFilter *filefilter; extern char *get_xdir_fs (void); char *token; char *tokenbuffer; #if 0 /* native file dialogs */ #ifdef WIN32 if (!(flags & FRF_WRITE)) { freq = malloc (sizeof (struct file_req)); freq->th = thread_new (); freq->flags = 0; freq->multiple = (flags & FRF_MULTIPLE); freq->callback = callback; freq->userdata = userdata; freq->title = g_locale_from_utf8 (title, -1, 0, 0, 0); if (!filter) { freq->filter = "All files\0*.*\0" "Executables\0*.exe\0" "ZIP files\0*.zip\0\0"; } else { freq->filter = filter; } thread_start (freq->th, win32_thread, freq); fe_input_add (freq->th->pipe_fd[0], FIA_FD|FIA_READ, win32_read_thread, freq); return; } else { freq = malloc (sizeof (struct file_req)); freq->th = thread_new (); freq->flags = 0; freq->multiple = (flags & FRF_MULTIPLE); freq->callback = callback; freq->userdata = userdata; freq->title = g_locale_from_utf8 (title, -1, 0, 0, 0); if (!filter) { freq->filter = "All files\0*.*\0\0"; } else { freq->filter = filter; } thread_start (freq->th, win32_thread2, freq); fe_input_add (freq->th->pipe_fd[0], FIA_FD|FIA_READ, win32_read_thread, freq); return; } #endif #endif if (flags & FRF_WRITE) { dialog = gtk_file_chooser_dialog_new (title, NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); if (filter && filter[0]) /* filter becomes initial name when saving */ { char temp[1024]; path_part (filter, temp, sizeof (temp)); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), temp); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), file_part (filter)); } if (!(flags & FRF_NOASKOVERWRITE)) gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); } else dialog = gtk_file_chooser_dialog_new (title, NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); if (flags & FRF_MULTIPLE) gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE); if (last_dir[0]) gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), last_dir); if (flags & FRF_ADDFOLDER) gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), get_xdir_fs (), NULL); if (flags & FRF_CHOOSEFOLDER) { gtk_file_chooser_set_action (GTK_FILE_CHOOSER (dialog), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), filter); } else { if (filter && (flags & FRF_FILTERISINITIAL)) gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), filter); } if (flags & FRF_EXTENSIONS && extensions != NULL) { filefilter = gtk_file_filter_new (); tokenbuffer = g_strdup (extensions); token = strtok (tokenbuffer, ";"); while (token != NULL) { gtk_file_filter_add_pattern (filefilter, token); token = strtok (NULL, ";"); } g_free (tokenbuffer); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filefilter); } freq = malloc (sizeof (struct file_req)); freq->dialog = dialog; freq->flags = flags; freq->callback = callback; freq->userdata = userdata; g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (gtkutil_file_req_response), freq); g_signal_connect (G_OBJECT (dialog), "destroy", G_CALLBACK (gtkutil_file_req_destroy), (gpointer) freq); gtk_widget_show (dialog); }
void gtkutil_file_req (const char *title, void *callback, void *userdata, char *filter, char *extensions, int flags) { struct file_req *freq; GtkWidget *dialog; GtkFileFilter *filefilter; extern char *get_xdir_fs (void); char *token; char *tokenbuffer; if (flags & FRF_WRITE) { dialog = gtk_file_chooser_dialog_new (title, NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); if (!(flags & FRF_NOASKOVERWRITE)) gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); } else dialog = gtk_file_chooser_dialog_new (title, NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); if (filter && filter[0] && (flags & FRF_FILTERISINITIAL)) { if (flags & FRF_WRITE) { char temp[1024]; path_part (filter, temp, sizeof (temp)); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), temp); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), file_part (filter)); } else gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), filter); } else if (!(flags & FRF_RECENTLYUSED)) gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), get_xdir ()); if (flags & FRF_MULTIPLE) gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE); if (flags & FRF_CHOOSEFOLDER) gtk_file_chooser_set_action (GTK_FILE_CHOOSER (dialog), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); if ((flags & FRF_EXTENSIONS || flags & FRF_MIMETYPES) && extensions != NULL) { filefilter = gtk_file_filter_new (); tokenbuffer = g_strdup (extensions); token = strtok (tokenbuffer, ";"); while (token != NULL) { if (flags & FRF_EXTENSIONS) gtk_file_filter_add_pattern (filefilter, token); else gtk_file_filter_add_mime_type (filefilter, token); token = strtok (NULL, ";"); } g_free (tokenbuffer); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filefilter); } gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), get_xdir (), NULL); freq = malloc (sizeof (struct file_req)); freq->dialog = dialog; freq->flags = flags; freq->callback = callback; freq->userdata = userdata; g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (gtkutil_file_req_response), freq); g_signal_connect (G_OBJECT (dialog), "destroy", G_CALLBACK (gtkutil_file_req_destroy), (gpointer) freq); gtk_widget_show (dialog); }
char * plugin_load (session *sess, char *filename, char *arg) { void *handle; char *filepart; hexchat_init_func *init_func; hexchat_deinit_func *deinit_func; #ifndef USE_GMODULE char *error; #else char *pluginpath; #endif /* get the filename without path */ filepart = file_part (filename); #ifdef USE_GMODULE /* load the plugin */ if (!g_ascii_strcasecmp (filepart, filename)) { /* no path specified, it's just the filename, try to load from config dir */ pluginpath = g_build_filename (get_xdir (), filename, NULL); handle = g_module_open (pluginpath, 0); g_free (pluginpath); } else { /* try to load with absolute path */ handle = g_module_open (filename, 0); } if (handle == NULL) return (char *)g_module_error (); /* find the init routine hexchat_plugin_init */ if (!g_module_symbol (handle, "hexchat_plugin_init", (gpointer *)&init_func)) { g_module_close (handle); return _("No hexchat_plugin_init symbol; is this really a HexChat plugin?"); } /* find the plugin's deinit routine, if any */ if (!g_module_symbol (handle, "hexchat_plugin_deinit", (gpointer *)&deinit_func)) deinit_func = NULL; #else /* OpenBSD lacks this! */ #ifndef RTLD_GLOBAL #define RTLD_GLOBAL 0 #endif #ifndef RTLD_NOW #define RTLD_NOW 0 #endif /* load the plugin */ if (filepart && /* xsys draws in libgtk-1.2, causing crashes, so force RTLD_LOCAL */ (strstr (filepart, "local") || strncmp (filepart, "libxsys-1", 9) == 0) ) handle = dlopen (filename, RTLD_NOW); else handle = dlopen (filename, RTLD_GLOBAL | RTLD_NOW); if (handle == NULL) return (char *)dlerror (); dlerror (); /* Clear any existing error */ /* find the init routine hexchat_plugin_init */ init_func = dlsym (handle, "hexchat_plugin_init"); error = (char *)dlerror (); if (error != NULL) { dlclose (handle); return _("No hexchat_plugin_init symbol; is this really a HexChat plugin?"); } /* find the plugin's deinit routine, if any */ deinit_func = dlsym (handle, "hexchat_plugin_deinit"); error = (char *)dlerror (); #endif /* add it to our linked list */ plugin_add (sess, filename, handle, init_func, deinit_func, arg, FALSE); return NULL; }
void fe_dcc_update_send_win (void) { struct DCC *dcc; GSList *list = dcc_list; gchar *nnew[9]; char size[14]; char pos[14]; char cps[14]; char ack[14]; char perc[14]; char eta[14]; gint row; int selrow; int to_go; float per; if (!dccswin.window) return; selrow = gtkutil_clist_selection (dccswin.list); gtk_clist_clear ((GtkCList *) dccswin.list); nnew[2] = size; nnew[3] = pos; nnew[4] = ack; nnew[5] = perc; nnew[6] = cps; while (list) { nnew[7] = eta; dcc = (struct DCC *) list->data; if (dcc->type == TYPE_SEND) { nnew[0] = _(dccstat[(int) dcc->dccstat].name); nnew[1] = file_part (dcc->file); nnew[8] = dcc->nick; /* percentage ack'ed */ per = (float) ((dcc->ack * 100.00) / dcc->size); snprintf (size, sizeof (size), "%d", dcc->size); snprintf (pos, sizeof (pos), "%d", dcc->pos); snprintf (cps, sizeof (cps), "%d", dcc->cps); snprintf (perc, sizeof (perc), "%.0f%%", per); snprintf (ack, sizeof (ack), "%d", dcc->ack); if (dcc->cps != 0) { to_go = (dcc->size - dcc->ack) / dcc->cps; snprintf (eta, sizeof (eta), "%.2d:%.2d:%.2d", to_go / 3600, (to_go / 60) % 60, to_go % 60); } else strcpy (eta, "--:--:--"); row = gtk_clist_append (GTK_CLIST (dccswin.list), nnew); gtk_clist_set_row_data (GTK_CLIST (dccswin.list), row, (gpointer) dcc); if (dccstat[(int) dcc->dccstat].color != 1) gtk_clist_set_foreground (GTK_CLIST (dccswin.list), row, colors + dccstat[(int) dcc->dccstat].color); } list = list->next; } if (selrow != -1) gtk_clist_select_row ((GtkCList *) dccswin.list, selrow, 0); }
void gtkutil_file_req (const char *title, void *callback, void *userdata, char *filter, char *extensions, int flags) { struct file_req *freq; GtkWidget *dialog; GtkFileFilter *filefilter; extern char *get_xdir_fs (void); char *token; char *tokenbuffer; #if 0 /* native file dialogs */ #ifdef WIN32 if (!(flags & FRF_WRITE)) { freq = malloc (sizeof (struct file_req)); freq->th = thread_new (); freq->flags = 0; freq->multiple = (flags & FRF_MULTIPLE); freq->callback = callback; freq->userdata = userdata; freq->title = g_locale_from_utf8 (title, -1, 0, 0, 0); if (!filter) { freq->filter = "All files\0*.*\0" "Executables\0*.exe\0" "ZIP files\0*.zip\0\0"; } else { freq->filter = filter; } thread_start (freq->th, win32_thread, freq); fe_input_add (freq->th->pipe_fd[0], FIA_FD|FIA_READ, win32_read_thread, freq); return; } else { freq = malloc (sizeof (struct file_req)); freq->th = thread_new (); freq->flags = 0; freq->multiple = (flags & FRF_MULTIPLE); freq->callback = callback; freq->userdata = userdata; freq->title = g_locale_from_utf8 (title, -1, 0, 0, 0); if (!filter) { freq->filter = "All files\0*.*\0\0"; } else { freq->filter = filter; } thread_start (freq->th, win32_thread2, freq); fe_input_add (freq->th->pipe_fd[0], FIA_FD|FIA_READ, win32_read_thread, freq); return; } #endif #endif if (flags & FRF_WRITE) { dialog = gtk_file_chooser_dialog_new (title, NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); if (filter && filter[0]) /* filter becomes initial name when saving */ { char temp[1024]; path_part (filter, temp, sizeof (temp)); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), temp); gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), file_part (filter)); } if (!(flags & FRF_NOASKOVERWRITE)) gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE); } else dialog = gtk_file_chooser_dialog_new (title, NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); if (flags & FRF_MULTIPLE) gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), TRUE); if (last_dir[0]) gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), last_dir); if (flags & FRF_ADDFOLDER) gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), get_xdir (), NULL); if (flags & FRF_CHOOSEFOLDER) { gtk_file_chooser_set_action (GTK_FILE_CHOOSER (dialog), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), filter); } else { if (filter && (flags & FRF_FILTERISINITIAL)) { gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), filter); } /* With DCC, we can't rely on filter as initial folder since filter already contains * the filename upon DCC RECV. Thus we have no better option than to check for the message * which will be the title of the window. For DCC it always contains the "offering" word. * This method is really ugly but it works so we'll stick with it for now. */ else if (strstr (title, "offering") != NULL) { gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), prefs.hex_dcc_dir); } /* by default, open the config folder */ else { gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), get_xdir ()); } } if (flags & FRF_EXTENSIONS && extensions != NULL) { filefilter = gtk_file_filter_new (); tokenbuffer = g_strdup (extensions); token = strtok (tokenbuffer, ";"); while (token != NULL) { gtk_file_filter_add_pattern (filefilter, token); token = strtok (NULL, ";"); } g_free (tokenbuffer); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filefilter); } freq = malloc (sizeof (struct file_req)); freq->dialog = dialog; freq->flags = flags; freq->callback = callback; freq->userdata = userdata; g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (gtkutil_file_req_response), freq); g_signal_connect (G_OBJECT (dialog), "destroy", G_CALLBACK (gtkutil_file_req_destroy), (gpointer) freq); gtk_widget_show (dialog); }
indx_t jigsaw_load_msh_t ( // load msh_t char *_fchr, jigsaw_msh_t *_jmsh ) { class msht_reader: public jmsh_reader_base { public : jigsaw_msh_t *_jmsh ; std::int32_t _errv ; std::int32_t _ftag ; jmsh_kind:: enum_data _kind ; std::int32_t _ndim ; std::int32_t _nval ; public : __normal_call msht_reader ( jigsaw_msh_t *_jsrc = nullptr ) : _jmsh(_jsrc) , _errv( +0 ) {} /*-------------------------------- read MSHID section */ __normal_call void_type push_mshid ( std::int32_t _ftag , jmsh_kind::enum_data _kind ) { this->_ftag = _ftag ; this->_kind = _kind ; this->_jmsh->_flags = JIGSAW_NULL_FLAG; if (_kind == jmsh_kind::euclidean_mesh) this->_jmsh->_flags = JIGSAW_EUCLIDEAN_MESH ; else if (_kind == jmsh_kind::euclidean_grid) this->_jmsh->_flags = JIGSAW_EUCLIDEAN_GRID ; else if (_kind == jmsh_kind::ellipsoid_mesh) this->_jmsh->_flags = JIGSAW_ELLIPSOID_MESH ; else if (_kind == jmsh_kind::ellipsoid_grid) this->_jmsh->_flags = JIGSAW_ELLIPSOID_GRID ; } /*-------------------------------- read NDIMS section */ __normal_call void_type push_ndims ( std::int32_t _ndim ) { this->_ndim = _ndim ; } /*-------------------------------- read RADII section */ __normal_call void_type push_radii ( double *_erad ) { jigsaw_alloc_reals ( &this->_jmsh->_radii, +3 ) ; this->_jmsh-> _radii._data[0] = _erad[0] ; this->_jmsh-> _radii._data[1] = _erad[1] ; this->_jmsh-> _radii._data[2] = _erad[2] ; } /*-------------------------------- open POINT section */ __normal_call void_type open_point ( std:: size_t _nrow ) { if (this->_kind == jmsh_kind:: euclidean_mesh) { if (this->_ndim == +2) jigsaw_alloc_vert2 ( &this->_jmsh->_vert2, _nrow) ; else if (this->_ndim == +3) jigsaw_alloc_vert3 ( &this->_jmsh->_vert3, _nrow) ; jigsaw_alloc_reals ( &this->_jmsh->_power, _nrow) ; } else if (this->_kind == jmsh_kind:: ellipsoid_mesh) { if (this->_ndim == +2) jigsaw_alloc_vert2 ( &this->_jmsh->_vert2, _nrow) ; else if (this->_ndim == +3) jigsaw_alloc_vert3 ( &this->_jmsh->_vert3, _nrow) ; jigsaw_alloc_reals ( &this->_jmsh->_power, _nrow) ; } } /*-------------------------------- read POINT section */ __normal_call void_type push_point ( std:: size_t _ipos , double *_pval , std::int32_t _itag ) { if (this->_ndim == +2 ) { if (_ipos < this->_jmsh->_vert2._size) { this->_jmsh->_vert2._data[_ipos]. _ppos[0] = _pval[0] ; this->_jmsh->_vert2._data[_ipos]. _ppos[1] = _pval[1] ; this->_jmsh->_vert2. _data[_ipos]._itag = _itag ; this->_jmsh-> _power._data[_ipos] = +0.00 ; } else { this->_errv =__invalid_argument ; } } else if (this->_ndim == +3 ) { if (_ipos < this->_jmsh->_vert2._size) { this->_jmsh->_vert3._data[_ipos]. _ppos[0] = _pval[0] ; this->_jmsh->_vert3._data[_ipos]. _ppos[1] = _pval[1] ; this->_jmsh->_vert3._data[_ipos]. _ppos[2] = _pval[2] ; this->_jmsh->_vert3. _data[_ipos]._itag = _itag ; this->_jmsh-> _power._data[_ipos] = +0.00 ; } else { this->_errv =__invalid_argument ; } } } /*-------------------------------- read POWER section */ __normal_call void_type push_power ( std:: size_t _ipos, double * _xpwr ) { if (this->_ndim == +2 ) { if (_ipos < this->_jmsh->_vert2._size) { this->_jmsh->_power. _data[_ipos] = _xpwr[ +0] ; } else { this->_errv =__invalid_argument ; } } else if (this->_ndim == +3 ) { if (_ipos < this->_jmsh->_vert3._size) { this->_jmsh->_power. _data[_ipos] = _xpwr[ +0] ; } else { this->_errv =__invalid_argument ; } } } /*-------------------------------- open COORD section */ __normal_call void_type open_coord ( std:: size_t _idim, std:: size_t _nrow ) { if (_idim == +1) jigsaw_alloc_reals ( &this->_jmsh->_xgrid, _nrow) ; else if (_idim == +2) jigsaw_alloc_reals ( &this->_jmsh->_ygrid, _nrow) ; else if (_idim == +3) jigsaw_alloc_reals ( &this->_jmsh->_zgrid, _nrow) ; } /*-------------------------------- read COORD section */ __normal_call void_type push_coord ( std:: size_t _idim, std:: size_t _ipos, double _ppos ) { if (_idim == +1) { if (_ipos < this->_jmsh->_xgrid._size) { this->_jmsh->_xgrid. _data[_ipos] = _ppos ; } else { this->_errv = __invalid_argument ; } } else if (_idim == +2) { if (_ipos < this->_jmsh->_ygrid._size) { this->_jmsh->_ygrid. _data[_ipos] = _ppos ; } else { this->_errv = __invalid_argument ; } } else if (_idim == +3) { if (_ipos < this->_jmsh->_zgrid._size) { this->_jmsh->_zgrid. _data[_ipos] = _ppos ; } else { this->_errv = __invalid_argument ; } } } /*-------------------------------- open EDGE2 section */ __normal_call void_type open_edge2 ( std:: size_t _nrow ) { jigsaw_alloc_edge2 ( &this->_jmsh->_edge2, _nrow) ; } /*-------------------------------- push EDGE2 section */ __normal_call void_type push_edge2 ( std:: size_t _ipos, std::int32_t* _node, std::int32_t _itag ) { if (_ipos < this->_jmsh->_edge2._size) { this->_jmsh->_edge2._data[_ipos]. _node[0] = _node[0] ; this->_jmsh->_edge2._data[_ipos]. _node[1] = _node[1] ; this->_jmsh->_edge2. _data[_ipos]._itag = _itag ; } else { this->_errv =__invalid_argument ; } } /*-------------------------------- open TRIA3 section */ __normal_call void_type open_tria3 ( std:: size_t _nrow ) { jigsaw_alloc_tria3 ( &this->_jmsh->_tria3, _nrow) ; } /*-------------------------------- push TRIA3 section */ __normal_call void_type push_tria3 ( std:: size_t _ipos, std::int32_t* _node, std::int32_t _itag ) { if (_ipos < this->_jmsh->_tria3._size) { this->_jmsh->_tria3._data[_ipos]. _node[0] = _node[0] ; this->_jmsh->_tria3._data[_ipos]. _node[1] = _node[1] ; this->_jmsh->_tria3._data[_ipos]. _node[2] = _node[2] ; this->_jmsh->_tria3. _data[_ipos]._itag = _itag ; } else { this->_errv =__invalid_argument ; } } /*-------------------------------- open TRIA4 section */ __normal_call void_type open_tria4 ( std:: size_t _nrow ) { jigsaw_alloc_tria4 ( &this->_jmsh->_tria4, _nrow) ; } /*-------------------------------- push TRIA4 section */ __normal_call void_type push_tria4 ( std:: size_t _ipos, std::int32_t* _node, std::int32_t _itag ) { if (_ipos < this->_jmsh->_tria4._size) { this->_jmsh->_tria4._data[_ipos]. _node[0] = _node[0] ; this->_jmsh->_tria4._data[_ipos]. _node[1] = _node[1] ; this->_jmsh->_tria4._data[_ipos]. _node[2] = _node[2] ; this->_jmsh->_tria4._data[_ipos]. _node[3] = _node[3] ; this->_jmsh->_tria4. _data[_ipos]._itag = _itag ; } else { this->_errv =__invalid_argument ; } } /*-------------------------------- open BOUND section */ __normal_call void_type open_bound ( std:: size_t _nrow ) { jigsaw_alloc_bound ( &this->_jmsh->_bound, _nrow) ; } /*-------------------------------- push BOUND section */ __normal_call void_type push_bound ( std:: size_t _ipos, std::int32_t _itag, std::int32_t _inum, std::int32_t _kind ) { if (_ipos < this->_jmsh->_bound._size) { this->_jmsh->_bound. _data[_ipos]._itag = _itag ; this->_jmsh->_bound. _data[_ipos]._indx = _inum ; this->_jmsh->_bound. _data[_ipos]._kind = _kind ; } else { this->_errv =__invalid_argument ; } } /*-------------------------------- open VALUE section */ __normal_call void_type open_value ( std:: size_t _nrow, std:: size_t _nval ) { this->_nval = _nval; jigsaw_alloc_reals ( &this-> _jmsh->_value , _nrow * _nval ) ; } /*-------------------------------- push VALUE section */ __normal_call void_type push_value ( std:: size_t _ipos, double * _vdat ) { if (_ipos < this->_jmsh->_value._size) { for (auto _ival = +0; _ival< this->_nval; ++_ival) { this->_jmsh->_value. _data[_ipos*(_ival+1)] = _vdat[_ival]; } } else { this->_errv = __invalid_argument; } } } ; /*---------------------------------- parse MSH_T file */ iptr_type _errv = __no_error ; try { jmsh_reader _read ; std::ifstream _file ; std::string _fstr(_fchr) ; std::string _path ; std::string _name ; std::string _fext ; file_part(_fstr, _path, _name, _fext) ; _file.open( _fstr, std::ifstream:: in) ; if (_file.is_open() ) { _read.read_file ( _file, msht_reader(_jmsh)) ; } else { _errv = __file_not_located ; } _file.close (); if(!_read._errs.empty()) { _errv = __invalid_argument ; } } catch (...) { _errv = __unknown_error ; } /*---------------------------------- return read flag */ return _errv ; }