/* * Given a list of toplevel vdevs, return the current replication level. If * the config is inconsistent, then NULL is returned. If 'fatal' is set, then * an error message will be displayed for each self-inconsistent vdev. */ replication_level_t * get_replication(nvlist_t *nvroot, boolean_t fatal) { nvlist_t **top; uint_t t, toplevels; nvlist_t **child; uint_t c, children; nvlist_t *nv; char *type; replication_level_t lastrep, rep, *ret; boolean_t dontreport; ret = safe_malloc(sizeof (replication_level_t)); verify(nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, &top, &toplevels) == 0); lastrep.zprl_type = NULL; for (t = 0; t < toplevels; t++) { nv = top[t]; verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0); if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, &child, &children) != 0) { /* * This is a 'file' or 'disk' vdev. */ rep.zprl_type = type; rep.zprl_children = 1; rep.zprl_parity = 0; } else { uint64_t vdev_size; /* * This is a mirror or RAID-Z vdev. Go through and make * sure the contents are all the same (files vs. disks), * keeping track of the number of elements in the * process. * * We also check that the size of each vdev (if it can * be determined) is the same. */ rep.zprl_type = type; rep.zprl_children = 0; if (strcmp(type, VDEV_TYPE_RAIDZ) == 0) { verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NPARITY, &rep.zprl_parity) == 0); assert(rep.zprl_parity != 0); } else { rep.zprl_parity = 0; } /* * The 'dontreport' variable indicatest that we've * already reported an error for this spec, so don't * bother doing it again. */ type = NULL; dontreport = 0; vdev_size = -1ULL; for (c = 0; c < children; c++) { nvlist_t *cnv = child[c]; char *path; struct stat statbuf; uint64_t size = -1ULL; char *childtype; int fd, err; rep.zprl_children++; verify(nvlist_lookup_string(cnv, ZPOOL_CONFIG_TYPE, &childtype) == 0); /* * If this is a a replacing or spare vdev, then * get the real first child of the vdev. */ if (strcmp(childtype, VDEV_TYPE_REPLACING) == 0 || strcmp(childtype, VDEV_TYPE_SPARE) == 0) { nvlist_t **rchild; uint_t rchildren; verify(nvlist_lookup_nvlist_array(cnv, ZPOOL_CONFIG_CHILDREN, &rchild, &rchildren) == 0); assert(rchildren == 2); cnv = rchild[0]; verify(nvlist_lookup_string(cnv, ZPOOL_CONFIG_TYPE, &childtype) == 0); } verify(nvlist_lookup_string(cnv, ZPOOL_CONFIG_PATH, &path) == 0); /* * If we have a raidz/mirror that combines disks * with files, report it as an error. */ if (!dontreport && type != NULL && strcmp(type, childtype) != 0) { if (ret != NULL) free(ret); ret = NULL; if (fatal) vdev_error(gettext( "mismatched replication " "level: %s contains both " "files and devices\n"), rep.zprl_type); else return (NULL); dontreport = B_TRUE; } /* * According to stat(2), the value of 'st_size' * is undefined for block devices and character * devices. But there is no effective way to * determine the real size in userland. * * Instead, we'll take advantage of an * implementation detail of spec_size(). If the * device is currently open, then we (should) * return a valid size. * * If we still don't get a valid size (indicated * by a size of 0 or MAXOFFSET_T), then ignore * this device altogether. */ if ((fd = open(path, O_RDONLY)) >= 0) { err = fstat(fd, &statbuf); (void) close(fd); } else { err = stat(path, &statbuf); } if (err != 0 || statbuf.st_size == 0 || statbuf.st_size == MAXOFFSET_T) continue; size = statbuf.st_size; /* * Also check the size of each device. If they * differ, then report an error. */ if (!dontreport && vdev_size != -1ULL && size != vdev_size) { if (ret != NULL) free(ret); ret = NULL; if (fatal) vdev_error(gettext( "%s contains devices of " "different sizes\n"), rep.zprl_type); else return (NULL); dontreport = B_TRUE; } type = childtype; vdev_size = size; } } /* * At this point, we have the replication of the last toplevel * vdev in 'rep'. Compare it to 'lastrep' to see if its * different. */ if (lastrep.zprl_type != NULL) { if (strcmp(lastrep.zprl_type, rep.zprl_type) != 0) { if (ret != NULL) free(ret); ret = NULL; if (fatal) vdev_error(gettext( "mismatched replication level: " "both %s and %s vdevs are " "present\n"), lastrep.zprl_type, rep.zprl_type); else return (NULL); } else if (lastrep.zprl_parity != rep.zprl_parity) { if (ret) free(ret); ret = NULL; if (fatal) vdev_error(gettext( "mismatched replication level: " "both %llu and %llu device parity " "%s vdevs are present\n"), lastrep.zprl_parity, rep.zprl_parity, rep.zprl_type); else return (NULL); } else if (lastrep.zprl_children != rep.zprl_children) { if (ret) free(ret); ret = NULL; if (fatal) vdev_error(gettext( "mismatched replication level: " "both %llu-way and %llu-way %s " "vdevs are present\n"), lastrep.zprl_children, rep.zprl_children, rep.zprl_type); else return (NULL); } } lastrep = rep; } if (ret != NULL) *ret = rep; return (ret); }
int vsvks(int metka, //0-внесение денег в кассу 1-выдача из кассы денег const char *kod_kl, double saldo_r, struct KASSA *kasr) { class vsvks_vs_data data; if(kod_kl[0] == '\0') { if(iceb_mous_klav(gettext("Введите код клиента"),&data.kodkl,20,0,0,1,NULL) != 0) return(1); } else data.kodkl.new_plus(kod_kl); class iceb_gdite_data gdite; iceb_gdite(&gdite,1,NULL); //Проверяем код клиента char strsql[512]; SQL_str row; SQLCURSOR cur; sprintf(strsql,"select fio from Taxiklient where kod='%s'",data.kodkl.ravno()); if(iceb_sql_readkey(strsql,&row,&cur,NULL) != 1) { iceb_menu_soob(gettext("Не найдено код клиента !"),NULL); return(1); } iceb_refresh(); //double saldo_pered_1neopl=0.; //double saldo_po_kas=0.; data.saldo_kon=saldo_r; data.kasr=kasr; data.metka=metka; data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); if(metka_skreen == 1) gtk_widget_set_usize(data.window,-1,400); iceb_u_str repl; if(metka == 1) { repl.plus(gettext("Выдача из кассы клиенту")); sprintf(strsql,"%s %s",name_system, gettext("Выдача из кассы клиенту")); data.znak_sum=-1; } if(metka == 0) { repl.plus(gettext("Внесение в кассу клиентом")); sprintf(strsql,"%s %s",name_system,gettext("Внесение в кассу клиентом")); data.znak_sum=1; } gtk_window_set_title (GTK_WINDOW (data.window),strsql); gtk_container_set_border_width (GTK_CONTAINER (data.window), 5); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(vsvks_vs_v_key_press),&data); GtkWidget *label=NULL; repl.ps_plus(data.kodkl.ravno()); repl.plus(" "); repl.plus(row[0]); repl.ps_plus(gettext("Сальдо")); repl.plus(":"); repl.plus(data.saldo_kon); label=gtk_label_new(repl.ravno_toutf()); GtkWidget *vbox = gtk_vbox_new (FALSE, 0); GtkWidget *hbox[KOLENTER]; for(int i=0; i < KOLENTER; i++) hbox[i] = gtk_hbox_new (FALSE, 0); GtkWidget *hboxknop=gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (data.window), vbox); gtk_container_add (GTK_CONTAINER (vbox), label); for(int i=0; i < KOLENTER; i++) gtk_container_add (GTK_CONTAINER (vbox), hbox[i]); gtk_container_add (GTK_CONTAINER (vbox), hboxknop); data.knopka_suma=gtk_button_new_with_label(gettext("Сумма")); gtk_box_pack_start (GTK_BOX (hbox[E_SUMA]), data.knopka_suma, FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_suma),"clicked",GTK_SIGNAL_FUNC(vsvks_v_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_suma),(gpointer)E_SUMA); data.entry[E_SUMA] = gtk_entry_new_with_max_length (20); gtk_box_pack_start (GTK_BOX (hbox[E_SUMA]), data.entry[E_SUMA], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_SUMA]), "activate",GTK_SIGNAL_FUNC(vsvks_vs_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_SUMA]),data.suma.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_SUMA]),(gpointer)E_SUMA); data.knopka_suma=gtk_button_new_with_label(gettext("Коментарий")); gtk_box_pack_start (GTK_BOX (hbox[E_KOMENT]), data.knopka_suma, FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_suma),"clicked",GTK_SIGNAL_FUNC(vsvks_v_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_suma),(gpointer)E_KOMENT); data.entry[E_KOMENT] = gtk_entry_new_with_max_length (20); gtk_box_pack_start (GTK_BOX (hbox[E_KOMENT]), data.entry[E_KOMENT], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_KOMENT]), "activate",GTK_SIGNAL_FUNC(vsvks_vs_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOMENT]),data.koment.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOMENT]),(gpointer)E_KOMENT); label=gtk_label_new(gettext("Нaлог")); gtk_box_pack_start (GTK_BOX (hbox[E_VIDNAL]), label, FALSE, FALSE, 0); GtkWidget *menu_vidnal = vsvks_vidnal(&data.vidnal); gtk_box_pack_start (GTK_BOX (hbox[E_VIDNAL]), menu_vidnal, TRUE, TRUE, 0); GtkTooltips *tooltips[KOL_F_KL]; sprintf(strsql,"F2 %s",gettext("Ввод")); data.knopka[FK2]=gtk_button_new_with_label(strsql); tooltips[FK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Пополнение счёта клиента"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(vsvks_vs_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE, 0); sprintf(strsql,"F3 %s",gettext("Выдача карточки")); data.knopka[FK3]=gtk_button_new_with_label(strsql); tooltips[FK3]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK3],data.knopka[FK3],gettext("Выдача карточки клиенту с вводом на счёт клиента начальной суммы"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK3]),"clicked",GTK_SIGNAL_FUNC(vsvks_vs_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK3]),(gpointer)FK3); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK3], TRUE, TRUE, 0); sprintf(strsql,"F4 %s",gettext("Очистить")); data.knopka[FK4]=gtk_button_new_with_label(strsql); tooltips[FK4]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Очистить меню от введенной информации"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]),"clicked",GTK_SIGNAL_FUNC(vsvks_vs_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK4], TRUE, TRUE, 0); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka[FK10]=gtk_button_new_with_label(strsql); tooltips[FK10]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(vsvks_vs_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE, 0); gtk_widget_grab_focus(data.entry[0]); gdite.close(); gtk_widget_show_all (data.window); gtk_main(); return(data.voz); }
/* * set_mntpt() looks at the entity's name (e_name) and finds its * mountpoint. To do this, we need to build a list of mountpoints * from /etc/mnttab. We only need to do this once and we don't do it * if we don't need to look at any mountpoints. * Returns 0 on success, non-zero if it couldn't find a mount-point. */ int set_mntpt(entity_t *ep) { static struct mnt { struct mnt *m_next; char *m_mntpt; ulong_t m_fsid; /* From statvfs(), set only as needed */ } *mnt_list = NULL; /* Linked list of mount-points */ struct mnt *mntp; struct statvfs64 statvfsbuf; char *original_name = ep->e_name; char path[PATH_MAX]; if (original_name == NULL) /* Shouldn't happen */ return (1); /* We only set up mnt_list the first time this is called */ if (mnt_list == NULL) { FILE *fp; struct mnttab mnttab; if ((fp = fopen(MNTTAB, "r")) == NULL) { perror(MNTTAB); return (1); } resetmnttab(fp); /* * We insert at the front of the list so that when we * search entries we'll have the last mounted entries * first in the list so that we can match the longest * mountpoint. */ while (getmntent(fp, &mnttab) == 0) { if ((mntp = malloc(sizeof (*mntp))) == NULL) { perror("malloc() mount list"); return (1); } mntp->m_mntpt = strdup(mnttab.mnt_mountp); mntp->m_next = mnt_list; mnt_list = mntp; } (void) fclose(fp); } if (realpath(original_name, path) == NULL) { perror(original_name); return (1); } /* * Now that we have the path, walk through the mnt_list and * look for the first (best) match. */ for (mntp = mnt_list; mntp; mntp = mntp->m_next) { if (strncmp(path, mntp->m_mntpt, strlen(mntp->m_mntpt)) == 0) { if (mntp->m_fsid == 0) { if (statvfs64(mntp->m_mntpt, &statvfsbuf)) { /* Can't statvfs so no match */ continue; } else { mntp->m_fsid = statvfsbuf.f_fsid; } } if (ep->e_fsid != mntp->m_fsid) { /* No match - Move on */ continue; } break; } } if (mntp == NULL) { (void) fprintf(stderr, gettext( "Can't find mount point for %s\n"), path); return (1); } ep->e_name = strdup(mntp->m_mntpt); free(original_name); return (0); }
/* * Function: addrFunc * * Arguments: char *configFile, char *Section, char *Label, int command * int argc, char *argv[] * Description: This function will take apart the argc/argv array, check the * number of parameters, and call the appropriate function * based on the command code. * * Returns: int (zero on success) */ int addrFunc(char *configFile, char *Section, char *Label, int command, int argc, char *argv[]) { char DestSection[MAX_SECTION_LEN]; FuncEntry *funcEntry = NULL; int (*function)(char *, char *, char *, int, int, char **) = NULL; char *validStrings[] = { "Node-Default", NULL }; /* Use Section and label to get rid of lint warnings */ Section = Label; /* ARGV[0] should be the Address */ if (argc < 1) { (void) fprintf(stderr, gettext("Error: address identifier was not specified. " "Please specify an identifier for the Address section. " "Identifiers are either a valid IP address, an NAI " "(e.g. [email protected]), or ")); printValidStrings(validStrings); (void) fprintf(stderr, ".\n"); return (-1); } /* Validate Address */ if (!ipValid(argv[0]) && !naiValid(argv[0])) { /* Ok not a valid address, check for Defaults */ if (checkValidStrings(validStrings, argv[0])) { (void) fprintf(stderr, gettext("Error: invalid identifier for " "Address section. Identifier must " "be a valid IP address, a valid NAI " "(e.g. [email protected]), or ")); printValidStrings(validStrings); (void) fprintf(stderr, ".\n"); return (-1); } } /* Build our Section */ (void) sprintf(DestSection, "Address %s", argv[0]); /* Finally, look up our functions and call them based on the dest */ if (argc > 1) { funcEntry = getFunctions(addrFunctions, argv[1]); if (!funcEntry) { (void) fprintf(stderr, gettext("Error: command '%s' is not valid " "for %s.\n"), Command2Str(command), argv[1]); return (-1); } } /* Now check the particular function we need. */ switch (command) { case Add: if (argc == 1) { /* A raw add Warn the user */ (void) fprintf(stderr, gettext("Warning: attributes will be created as " "parameters are added.\n Example: " "mipagentconfig add addr 192.168.168.1 SPI 5\n " "will add the address, and add the SPI " "configuration to it.\n")); return (0); } function = funcEntry->addFunc; break; case Change: if (argc == 1) { (void) fprintf(stderr, gettext("Error: cannot change the identifier of an " "Address section. Delete, and make a new one.\n")); return (-1); } function = funcEntry->changeFunc; break; case Delete: if (argc == 1) { return DeletePrivateProfileSection(DestSection, configFile); } function = funcEntry->deleteFunc; break; case Get: if (argc == 1) { sectionDump(configFile, DestSection, addrFunctions); return (0); } function = funcEntry->getFunc; break; } /* Print error if this function is not allowed (null in table) */ if (!function) { (void) fprintf(stderr, gettext("Error: <%s> is not valid for '%s' command.\n"), argv[0], Command2Str(command)); return (-1); } /* And finally, call function */ return (function(configFile, DestSection, funcEntry->Label, command, argc-2, &argv[2])); } /* addrFunc */
extern "C" int addToGui(gpointer data) { plugData* plugdata=(plugData*)data; GtkTreeViewColumn* column; GtkTreeModel* model=NULL; GtkCellRenderer* renderer; GtkTreeIter iter; GtkWidget* menu; setTextDomain(true,plugdata); menu=gtk_menu_item_get_submenu((GtkMenuItem*)plugdata->mlist.menuView); hideMenu=gtk_menu_item_new_with_label(gettext("Hide Browser")); g_signal_connect(G_OBJECT(hideMenu),"activate",G_CALLBACK(toggleBrowser),plugdata); gtk_menu_shell_append(GTK_MENU_SHELL(menu),hideMenu); gtk_widget_show_all(plugdata->mlist.menuView); store=gtk_tree_store_new(NUM_COLUMNS,GDK_TYPE_PIXBUF,G_TYPE_STRING,G_TYPE_STRING); addFolderContents("/",&iter,true); model=GTK_TREE_MODEL(store); treeview=gtk_tree_view_new_with_model(model); gtk_tree_view_set_enable_tree_lines((GtkTreeView*)treeview,true); scrollbox=gtk_scrolled_window_new(NULL,NULL); gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrollbox,GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scrollbox),(GtkWidget*)treeview); gtk_box_pack_start((GtkBox*)plugdata->leftUserBox,scrollbox,true,true,0); gtk_widget_show_all(plugdata->leftUserBox); gtk_widget_set_size_request((GtkWidget*)scrollbox,100,-1); //pixbuf renderer=gtk_cell_renderer_pixbuf_new(); column=gtk_tree_view_column_new_with_attributes("path",renderer,"pixbuf",COLUMN_PIXBUF,NULL); gtk_tree_view_column_set_resizable(column,false); gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column((GtkTreeView*)treeview,column); gtk_tree_view_column_set_spacing(column,0); gtk_tree_view_column_set_expand(column,false); //colom file renderer=gtk_cell_renderer_text_new(); column=gtk_tree_view_column_new_with_attributes(NULL,renderer,"text",COLUMN_FILENAME,NULL); gtk_tree_view_column_set_resizable(column,true); gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column((GtkTreeView*)treeview,column); gtk_tree_view_column_set_expand(column,true); gtk_tree_view_column_set_spacing(column,0); gtk_tree_view_set_headers_visible((GtkTreeView*)treeview,false); g_signal_connect(treeview,"row-expanded",G_CALLBACK(expandRow),column); g_signal_connect(treeview,"row-collapsed",G_CALLBACK(collapseRow),column); g_signal_connect(treeview,"row-activated",G_CALLBACK(onRowActivated),NULL); leftBox=(GtkWidget*)plugdata->leftUserBox; doStartUpCheck(plugdata); showHideBrowser(plugdata,true); if(showing==true) showSide(true); else hideSide(true); setTextDomain(false,plugdata); return(0); }
gboolean gnc_xml_convert_single_file (const gchar *filename) { GncXmlImportData *data; GtkWidget *widget; GtkBuilder *builder; gboolean success; data = g_new0 (GncXmlImportData, 1); data->filename = gnc_uri_get_path (filename); data->canceled = FALSE; /* gather ambiguous info */ gxi_check_file (data); if (data->n_impossible == -1) return FALSE; if (!g_hash_table_size (data->ambiguous_ht)) { /* no ambiguous strings */ success = gxi_parse_file (data) && gxi_save_file (data); gxi_data_destroy (data); } else { /* common assistant initialization */ builder = gtk_builder_new(); gnc_builder_add_from_file (builder , "assistant-xml-encoding.glade", "assistant_xml_encoding"); data->assistant = GTK_WIDGET(gtk_builder_get_object (builder, "assistant_xml_encoding")); /* Enable buttons on all pages. */ gtk_assistant_set_page_complete (GTK_ASSISTANT (data->assistant), GTK_WIDGET(gtk_builder_get_object(builder, "start_page")), TRUE); gtk_assistant_set_page_complete (GTK_ASSISTANT (data->assistant), GTK_WIDGET(gtk_builder_get_object(builder, "conversion_page")), TRUE); gtk_assistant_set_page_complete (GTK_ASSISTANT (data->assistant), GTK_WIDGET(gtk_builder_get_object(builder, "end_page")), TRUE); /* start page, explanations */ gtk_assistant_set_page_title (GTK_ASSISTANT(data->assistant), gtk_assistant_get_nth_page (GTK_ASSISTANT(data->assistant), 0), gettext(encodings_doc_page_title)); widget = GTK_WIDGET(gtk_builder_get_object (builder, "start_page")); gtk_label_set_text (GTK_LABEL(widget), gettext (encodings_doc_string)); /* conversion page */ data->default_encoding_hbox = GTK_WIDGET(gtk_builder_get_object (builder, "default_enc_box")); data->string_box_container = GTK_WIDGET(gtk_builder_get_object (builder, "string_box_container")); data->impossible_label = GTK_WIDGET(gtk_builder_get_object (builder, "impossible_label")); /* finish page */ widget = GTK_WIDGET(gtk_builder_get_object(builder, "end_page")); gtk_label_set_text (GTK_LABEL(widget), gettext (finish_convert_string)); gtk_builder_connect_signals(builder, data); gtk_widget_show_all (data->assistant); gxi_update_default_enc_combo (data); gxi_update_string_box (data); g_object_unref(G_OBJECT(builder)); /* This won't return until the assistant is finished */ gtk_main(); if (data->canceled) success = FALSE; else success = gxi_save_file (data); } /* destroy all the data variables */ gxi_data_destroy (data); g_free (data); return success; }
/* * Function: addrTypeFunc * * Arguments: char *configFile, char *Section, char *Label, int command * int argc, char *argv[] * Description: This function verifys the Type option in address sections. * * Returns: int */ static int addrTypeFunc(char *configFile, char *Section, char *Label, int command, int argc, char *argv[]) { char buffer[MAX_VALUE_LEN]; int rc, LabelExists; char *validStrings[] = { "Agent", "Node", NULL }; /* Check to see if label already exists */ rc = GetPrivateProfileString(Section, Label, "", buffer, MAX_VALUE_LEN-1, configFile); if (!rc) LabelExists = TRUE; else LabelExists = FALSE; switch (command) { case Add: /* Now, check for the parameters. */ if (argc != 1) { (void) fprintf(stderr, gettext("Error: entry type wasn't specified. " "Please specify the type of entry for [%s]. " "The type must be one of ("), Section); printValidStrings(validStrings); (void) fprintf(stderr, ").\n"); return (-1); } if (LabelExists) { (void) fprintf(stderr, gettext("Error: %s is already configured in [%s]:\n" "\t%s = %s\n"), Label, Section, Label, buffer); return (-1); } if (!checkValidStrings(validStrings, argv[0])) { /* Add it! */ rc = WritePrivateProfileString(Section, Label, argv[0], configFile); if (rc) { (void) fprintf(stderr, "%s\n", ErrorString); return (rc); } return (0); } else { (void) fprintf(stderr, gettext("Error: Address type must be one of (")); printValidStrings(validStrings); (void) fprintf(stderr, ").\n"); return (-1); } break; case Delete: if (!LabelExists) { (void) fprintf(stderr, gettext("Error: %s is not configured in [%s].\n"), Label, Section); return (-1); } rc = DeletePrivateProfileLabel(Section, Label, configFile); if (rc) { (void) fprintf(stderr, "%s\n", ErrorString); return (rc); } return (rc); break; case Change: /* Now, check for the parameters. */ if (argc != 1) { (void) fprintf(stderr, gettext("Error: entry type wasn't specified. " "Please specify the type [%s] is to be changed to." " Valid types are one of ("), Section); printValidStrings(validStrings); (void) fprintf(stderr, ").\n"); return (-1); } if (!LabelExists) { (void) fprintf(stderr, gettext("Error: %s is not configured in [%s].\n"), Label, Section); return (-1); } if (!checkValidStrings(validStrings, argv[0])) { /* Change it! */ rc = WritePrivateProfileString(Section, Label, argv[0], configFile); if (rc) { (void) fprintf(stderr, "%s\n", ErrorString); return (rc); } return (0); } else { (void) fprintf(stderr, gettext("Error: type must be one of (")); printValidStrings(validStrings); (void) fprintf(stderr, ").\n"); return (-1); } break; case Get: if (!LabelExists) { (void) fprintf(stderr, gettext("Error: %s is not configured in [%s].\n"), Label, Section); return (-1); } (void) printf(gettext("[%s]\n\t%s = %s\n"), Section, Label, buffer); return (0); break; default: (void) fprintf(stderr, gettext("Error: Invalid command code!\n")); return (-1); } /* switch (command) */ } /* addrTypeFunc */
void l_usldoks(short ds,short ms,short gs, //Дата начала просмотра GtkWidget *wpredok) { usldoks_data data; char bros[512]; GdkColor color; data.ds=data.dn=ds; data.ms=data.mn=ms; data.gs=data.gn=gs; data.window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); //gtk_window_set_default_size (GTK_WINDOW (data.window),400,-1); //gdk_color_parse("black",&color); //gtk_widget_modify_bg(data.window,GTK_STATE_NORMAL,&color); sprintf(bros,"%s %s",name_system,gettext("Список документов")); gtk_window_set_title (GTK_WINDOW (data.window),bros); gtk_container_set_border_width (GTK_CONTAINER (data.window), 5); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); if(wpredok != NULL) { gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok)); //Закрыть окно если окно предок удалено gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE); } gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(usldoks_key_press),&data); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_release_event",GTK_SIGNAL_FUNC(iceb_key_release),&data.kl_shift); GtkWidget *hbox = gtk_hbox_new (FALSE, 1); gtk_container_add (GTK_CONTAINER (data.window), hbox); GtkWidget *vbox1 = gtk_vbox_new (FALSE, 1); GtkWidget *vbox2 = gtk_vbox_new (FALSE, 1); gtk_box_pack_start (GTK_BOX (hbox), vbox1, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0); gtk_widget_show(hbox); data.label_kolstr=gtk_label_new (gettext("Список документов")); gtk_box_pack_start (GTK_BOX (vbox2),data.label_kolstr,FALSE, FALSE, 0); gtk_widget_show(vbox1); gtk_widget_show(vbox2); data.label_poisk=gtk_label_new (""); /************ PangoFontDescription *font_pango=pango_font_description_from_string(shrift_ravnohir.ravno()); gtk_widget_modify_font(GTK_WIDGET(data.label_ost),font_pango); pango_font_description_free(font_pango); ***************/ gdk_color_parse("red",&color); gtk_widget_modify_fg(data.label_poisk,GTK_STATE_NORMAL,&color); gtk_box_pack_start (GTK_BOX (vbox2),data.label_poisk,FALSE, FALSE, 0); data.sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_usize(GTK_WIDGET(data.sw),-1,200); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (data.sw),GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (data.sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); //gtk_box_pack_start (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0); gtk_box_pack_end (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0); //Кнопки GtkTooltips *tooltips[KOL_F_KL]; sprintf(bros,"F2 ?"); data.knopka[FK2]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK2],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data); tooltips[FK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Включение/выключение показа только не подтверждённых документов"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2); gtk_widget_show(data.knopka[FK2]); sprintf(bros,"SF2 %s",gettext("Метка")); data.knopka[SFK2]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK2],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[SFK2]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data); tooltips[SFK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[SFK2],data.knopka[SFK2],gettext("Снятие метки неподтверждённого документа"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK2]),(gpointer)SFK2); gtk_widget_show(data.knopka[SFK2]); sprintf(bros,"F3 *"); data.knopka[FK3]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK3],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK3]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data); tooltips[FK3]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK3],data.knopka[FK3],gettext("Включение/выключение показа документов без проводок"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK3]),(gpointer)FK3); gtk_widget_show(data.knopka[FK3]); sprintf(bros,"SF3 %s",gettext("Метка")); data.knopka[SFK3]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK3],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[SFK3]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data); tooltips[SFK3]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[SFK3],data.knopka[SFK3],gettext("Снятие метки документа без проводок"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK3]),(gpointer)SFK3); gtk_widget_show(data.knopka[SFK3]); sprintf(bros,"F4 %s",gettext("Поиск")); data.knopka[FK4]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK4],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data); tooltips[FK4]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Поиск нужных записей"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4); gtk_widget_show(data.knopka[FK4]); sprintf(bros,"F5 %s",gettext("Просмотр")); data.knopka[FK5]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK5],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK5]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data); tooltips[FK5]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK5],data.knopka[FK5],gettext("Просмотр выбранного документа"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK5]),(gpointer)FK5); gtk_widget_show(data.knopka[FK5]); sprintf(bros,"F6 %s",gettext("Экспорт")); data.knopka[FK6]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK6],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK6]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data); tooltips[FK6]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK6],data.knopka[FK6],gettext("Экспорт кассовых ордеров в подсистему \"Учёт кассовых ордеров\""),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK6]),(gpointer)FK6); gtk_widget_show(data.knopka[FK6]); sprintf(bros,"F9 %s",gettext("Оплата")); data.knopka[FK9]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK9],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK9]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data); tooltips[FK9]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK9],data.knopka[FK9],gettext("Переключение режимов просмотра (только оплаченыые, только не оплаченные, все)"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK9]),(gpointer)FK9); gtk_widget_show(data.knopka[FK9]); sprintf(bros,"F10 %s",gettext("Выход")); data.knopka[FK10]=gtk_button_new_with_label(bros); gtk_box_pack_start(GTK_BOX(vbox1),data.knopka[FK10],TRUE,TRUE, 0); tooltips[FK10]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10); gtk_widget_show(data.knopka[FK10]); gtk_widget_realize(data.window); gdk_window_set_cursor(data.window->window,gdk_cursor_new(ICEB_CURSOR)); gtk_widget_grab_focus(data.knopka[FK10]); usldoks_create_list(&data); gtk_widget_show(data.window); //if(metka == 0) gtk_window_maximize(GTK_WINDOW(data.window)); //gtk_window_fullscreen(GTK_WINDOW(data.window)); gtk_main(); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); }
/* simply erases and redoes the text on the pixmap */ void menu_retext_pixmap(menu_st *menulist, int pixmap, item_st *item) { int op; char *text; if(pixmap < 0 || pixmap > menulist->screen_items - 1) { Dprintf("menu_retext_pixmap::No Such Pixmap\n"); return; } if(item < 0) { Dprintf("menu_retext_pixmap::Item non-existent\n"); return; } text = (TRANSLATE & menulist->op) ? gettext(item->text) : item->text; /* set the bit for a checked long item */ if(!(LONG_ITEM & item->op)) { GR_SIZE width, height, base; GrGetGCTextSize(menulist->menu_gc, text, -1, GR_TFASCII, &width, &height, &base); item->text_width = width; item->op |= LONG_ITEM; } menu_clear_pixmap(menulist, pixmap); if (UTF8 & menulist->op) op = GR_TFUTF8; else if (UC16 & menulist->op) op = GR_TFUC16; else if (ASCII & menulist->op) op = GR_TFASCII; /* this makes the text draw without outlines */ GrSetGCUseBackground(menulist->menu_gc, GR_FALSE); GrText(menulist->pixmaps[menulist->pixmap_pos[pixmap]], menulist->menu_gc, 8, 1, text, strlen(text), op | GR_TFTOP); if(BOOLEAN_MENU & item->op) { GR_SIZE width, height, base; char option[4]; /* get setting info */ if(item->setting != 0) item->sel_option = ipod_get_setting(item->setting); /* draw boolean text */ strcpy(option, (item->sel_option ? _("On") : _("Off"))); GrGetGCTextSize(menulist->menu_gc, option, -1, GR_TFASCII, &width, &height, &base); GrText(menulist->pixmaps[menulist->pixmap_pos[pixmap]], menulist->menu_gc, (menulist->w - width) - (8 + 2), 1, option, -1, GR_TFASCII| GR_TFTOP); } else if(OPTION_MENU & item->op) { GR_SIZE width, height, base; char **option; /* get setting info */ if(item->setting != 0) item->sel_option = ipod_get_setting(item->setting); /* draw option text */ option = (char **)item->action; text = gettext(option[item->sel_option]); GrGetGCTextSize(menulist->menu_gc, text, -1, GR_TFASCII, &width, &height, &base); GrText(menulist->pixmaps[menulist->pixmap_pos[pixmap]], menulist->menu_gc, (menulist->w - width) - (8 + 2), 1, text, -1, GR_TFASCII | GR_TFTOP); } else if((SUB_MENU_HEADER & item->op || ARROW_MENU & item->op) && (item->text_width < (menulist->w - 8) - 8)) { GrSetGCUseBackground(menulist->menu_gc, GR_FALSE); GrText(menulist->pixmaps[menulist->pixmap_pos[pixmap]], menulist->menu_gc, (menulist->w - 8) - 7, 2, ">", -1, GR_TFASCII | GR_TFTOP); GrText(menulist->pixmaps[menulist->pixmap_pos[pixmap]], menulist->menu_gc, (menulist->w - 8) - 6, 2, ">", -1, GR_TFASCII | GR_TFTOP); GrSetGCUseBackground(menulist->menu_gc, GR_TRUE); } menu_draw_item(menulist, pixmap); }
void usldoks_create_list (class usldoks_data *data) { class iceb_gdite_data gdite; iceb_gdite(&gdite,0,data->window); GtkListStore *model=NULL; GtkTreeIter iter; SQLCURSOR cur; SQLCURSOR cur1; char strsql[512]; char bros[500]; int kolstr=0; SQL_str row; iceb_u_str zagolov; data->kl_shift=0; //0-отжата 1-нажата gdk_window_set_cursor(data->window->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); iceb_refresh(); if(data->treeview != NULL) gtk_widget_destroy(data->treeview); data->treeview = gtk_tree_view_new(); gtk_container_add (GTK_CONTAINER (data->sw), data->treeview); g_signal_connect(data->treeview,"row_activated",G_CALLBACK(usldoks_v_row),data); GtkTreeSelection *selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(data->treeview)); gtk_tree_selection_set_mode(selection,GTK_SELECTION_SINGLE); g_signal_connect(selection,"changed",G_CALLBACK(usldoks_vibor),data); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (data->treeview), TRUE); //Устанавливаются полоски при отображении списка gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->treeview)),GTK_SELECTION_SINGLE); model = gtk_list_store_new (NUM_COLUMNS+1, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); sprintf(bros,"tp,datd,podr,kontr,nomd,nomnn,kodop,pod,pro,ktoi,nomdp,vrem,dover,nds,sumkor,sumnds,pn,mo from Usldokum"); sprintf(strsql,"select %s where datd >= '%d-01-01' order by datd asc", bros,data->gn); if(data->dn != 0) sprintf(strsql,"select %s where datd >= '%d-%02d-%02d' order by datd asc", bros,data->gn,data->mn,data->dn); if(data->dn != 0 && data->dk != 0) sprintf(strsql,"select %s where datd >= '%d-%02d-%02d' and datd <= '%d-%02d-%02d' \ order by datd asc",bros,data->gn,data->mn,data->dn,data->gk,data->mk,data->dk); data->zapros.new_plus(strsql); if((kolstr=cur.make_cursor(&bd,strsql)) < 0) { iceb_msql_error(&bd,gettext("Ошибка создания курсора !"),strsql,data->window); return; } //gtk_list_store_clear(model); iceb_u_str ss[NUM_COLUMNS]; data->kolzap=0; float kolstr1=0.; while(cur.read_cursor(&row) != 0) { iceb_pbar(gdite.bar,kolstr,++kolstr1); // printf("%s %s %s %s\n",row[0],row[1],row[2],row[3]); if(usldoks_prov_row(row,data) != 0) continue; //Метка записи ss[COL_METKAZ].new_plus(""); if(row[0][0] == '1') ss[COL_METKAZ].new_plus("+"); else ss[COL_METKAZ].new_plus("-"); if(row[7][0] == '0') ss[COL_METKAZ].plus("?"); if(row[8][0] == '0') ss[COL_METKAZ].plus("*"); if(row[17][0] == '0') ss[COL_METKAZ].plus("$"); //Дата документа ss[COL_DATAD].new_plus(iceb_u_sqldata(row[1])); //Номер документа ss[COL_NOMDOK].new_plus(iceb_u_toutf(row[4])); //Контрагент ss[COL_KONTR].new_plus(iceb_u_toutf(row[3])); //Код операции ss[COL_KODOP].new_plus(iceb_u_toutf(row[6])); //код подразделения ss[COL_PODR].new_plus(iceb_u_toutf(row[2])); //Номер налоговой накладной ss[COL_NOMNALNAK].new_plus(iceb_u_toutf(row[5])); //Номер накладной парного документа ss[COL_NOMPD].new_plus(iceb_u_toutf(row[10])); //Дата и время записи ss[COL_DATA_VREM].new_plus(iceb_u_toutf(iceb_u_vremzap(row[11]))); //Кто записал ss[COL_KTO].new_plus(iceb_kszap(row[9],0,data->window)); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, COL_METKAZ,ss[COL_METKAZ].ravno(), COL_DATAD,ss[COL_DATAD].ravno(), COL_NOMDOK,ss[COL_NOMDOK].ravno(), COL_KONTR,ss[COL_KONTR].ravno(), COL_KODOP,ss[COL_KODOP].ravno(), COL_PODR,ss[COL_PODR].ravno(), COL_NOMNALNAK,ss[COL_NOMNALNAK].ravno(), COL_NOMPD,ss[COL_NOMPD].ravno(), COL_DATA_VREM,ss[COL_DATA_VREM].ravno(), COL_KTO,ss[COL_KTO].ravno(), NUM_COLUMNS,data->kolzap, -1); data->kolzap++; } gtk_tree_view_set_model (GTK_TREE_VIEW(data-> treeview),GTK_TREE_MODEL (model)); g_object_unref (GTK_TREE_MODEL (model)); usldoks_add_columns (GTK_TREE_VIEW (data->treeview)); if(data->kolzap == 0) { gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK2]),FALSE);//Недоступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK3]),FALSE);//Недоступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK5]),FALSE);//Недоступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK6]),FALSE);//Недоступна } else { gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK2]),TRUE);//Доступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK3]),TRUE);//Доступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK5]),TRUE);//Доступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK6]),TRUE);//Доступна } gtk_widget_show (data->treeview); gtk_widget_show (data->sw); if(data->kolzap > 0) { if(data->snanomer > data->kolzap-1) data->snanomer= data->kolzap-1; if(data->snanomer < 0) data->snanomer=0; printf("poz=%d\n",data->snanomer); sprintf(strsql,"%d",data->snanomer); GtkTreePath *path=gtk_tree_path_new_from_string(strsql); // gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (data->treeview),path,NULL,TRUE,0,0); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (data->treeview),path,NULL,FALSE,0,0); gtk_tree_view_set_cursor(GTK_TREE_VIEW (data->treeview),path,NULL,FALSE); gtk_tree_path_free(path); // data->snanomer=-2; } iceb_u_str strpoi; strpoi.plus(""); if(data->poi.metka_pros == 1) strpoi.new_plus(gettext("Просмотр только неподтверждённых документов")); if(data->poi.metka_pros == 2) strpoi.new_plus(gettext("Просмотр только документов без проводок")); if(data->poi.metka_poi == 1 || data->poi.metka_opl != 0) { // printf("Формирование заголовка с реквизитами поиска.\n"); if(data->poi.metka_pros != 0) strpoi.ps_plus(gettext("Поиск")); else strpoi.new_plus(gettext("Поиск")); strpoi.plus(" !!!"); iceb_str_poisk(&strpoi,data->poi.nomdok.ravno(),gettext("Номер документа")); iceb_str_poisk(&strpoi,data->poi.datan.ravno(),gettext("Дата начала")); iceb_str_poisk(&strpoi,data->poi.datak.ravno(),gettext("Дата конца")); iceb_str_poisk(&strpoi,data->poi.kontr.ravno(),gettext("Код контрагента")); iceb_str_poisk(&strpoi,data->poi.naim_kontr.ravno(),gettext("Наименование контрагента")); iceb_str_poisk(&strpoi,data->poi.kodop.ravno(),gettext("Код операции")); iceb_str_poisk(&strpoi,data->poi.kodpod.ravno(),gettext("Код подразделения")); iceb_str_poisk(&strpoi,data->poi.nalnak.ravno(),gettext("Номер налоговой накладной")); iceb_str_poisk(&strpoi,data->poi.dover.ravno(),gettext("Доверенность")); if(data->poi.pr_ras.ravno_pr() == 1) strpoi.ps_plus(gettext("Только приходы")); if(data->poi.pr_ras.ravno_pr() == 2) strpoi.ps_plus(gettext("Только расходы")); if(data->poi.metka_opl == 1) strpoi.ps_plus(gettext("Только оплаченные")); if(data->poi.metka_opl == 2) strpoi.ps_plus(gettext("Только неоплаченные")); } if(strpoi.getdlinna() > 1) { gtk_label_set_text(GTK_LABEL(data->label_poisk),strpoi.ravno_toutf()); gtk_widget_show(data->label_poisk); } else gtk_widget_hide(data->label_poisk); zagolov.new_plus(gettext("Список документов")); sprintf(strsql," %s:%d",gettext("Количество записей"),data->kolzap); zagolov.plus(strsql); gtk_label_set_text(GTK_LABEL(data->label_kolstr),zagolov.ravno_toutf()); gtk_widget_show(data->label_kolstr); gdk_window_set_cursor(data->window->window,gdk_cursor_new(ICEB_CURSOR)); }
void l_usldoks_eko(class usldoks_data *data) { class iceb_gdite_data gdite; iceb_gdite(&gdite,0,data->window); SQL_str row; class SQLCURSOR cur; char strsql[512]; char shetk[32]; char naimop[512]; class zar_eks_ko_rek rek; if(eks_ko_v(&rek,data->window) != 0) return; //Проверяем код операции if(rek.prn == 1) sprintf(strsql,"select naik,shetkor from Kasop1 where kod='%s'",rek.kodop.ravno()); if(rek.prn == 2) sprintf(strsql,"select naik,shetkor from Kasop2 where kod='%s'",rek.kodop.ravno()); if(iceb_sql_readkey(strsql,&row,&cur,data->window) != 1) { sprintf(strsql,gettext("Не найден код операции %s !"),rek.kodop.ravno()); iceb_menu_soob(strsql,data->window); return; } memset(naimop,'\0',sizeof(naimop)); strncpy(naimop,row[0],sizeof(naimop)-1); strncpy(shetk,row[1],sizeof(shetk)-1); short dko=0,mko=0,gko=0; //Проверяем дату iceb_u_rsdat(&dko,&mko,&gko,rek.data.ravno(),1); short vt=0; iceb_poldan("Код группы возвратная тара",strsql,"matnast.alx",data->window); vt=atoi(strsql); class iceb_u_spisok kod_kontr; class iceb_u_double suma_kontr; class iceb_u_str nomd(""); double suma=0.; double sumabn=0.; double sumkor=0.; short d,m,g; int lnds=0; int kolih_kasord=0; double suma_nds=0.; double suma_dok=0.; float pnds=0.; int tipz_usl=0; if(rek.prn == 1) tipz_usl=2; else tipz_usl=1; int nomer_kontr=0; /************ tp,datd,podr,kontr,nomd,nomnn,kodop,pod,pro,ktoi,nomdp,vrem,dover,nds,sumkor,sumnds,pn ***************/ int kolstr=0; if((kolstr=cur.make_cursor(&bd,data->zapros.ravno())) < 0) { iceb_msql_error(&bd,gettext("Ошибка создания курсора !"),data->zapros.ravno(),data->window); return; } float kolstr1=0.; while(cur.read_cursor(&row) != 0) { iceb_pbar(gdite.bar,kolstr,++kolstr1); if(rek.prn == atoi(row[0])) /*Если приходный кассовый ордер то нам нужны расходные документы и наооборот*/ continue; if(usldoks_prov_row(row,data) != 0) continue; iceb_u_rsdat(&d,&m,&g,row[1],2); pnds=atof(row[16]); /*Узнаем НДС документа*/ lnds=atoi(row[13]); suma_nds=0.; if(lnds == 0) { suma_nds=atof(row[15]); } sumzap1uw(d,m,g,row[4],atoi(row[3]),&suma,&sumabn,lnds,tipz_usl,data->window); if(lnds == 0 && suma_nds == 0.) suma_nds=(suma+sumkor)*pnds/100.; /* printw("suma=%f sumabn=%f sumkor=%f\n",suma,sumabn,sumkor);*/ suma_dok=suma+sumkor+suma_nds+sumabn; if(rek.metka_r == 0) { kolih_kasord++; iceb_lock_tables("LOCK TABLES Kasord WRITE,icebuser READ"); iceb_nomnak(gko,rek.kassa.ravno(),&nomd,rek.prn,2,1,data->window); zaphkorw(0,rek.kassa.ravno(),rek.prn,dko,mko,gko,nomd.ravno(),shetk,rek.kodop.ravno(),naimop,"","","","","",0,0,0,"","",data->window); printf("%s:%s\n",gettext("Кассовый ордер"),nomd.ravno()); zapzkorw(rek.kassa.ravno(),rek.prn,dko,mko,gko,nomd.ravno(),row[4],suma_dok,"","",data->window); } else { if((nomer_kontr=kod_kontr.find_r(row[3])) < 0) kod_kontr.plus(row[3]); suma_kontr.plus(suma_dok,nomer_kontr); } } if(rek.metka_r == 1) { kolih_kasord++; iceb_lock_tables("LOCK TABLES Kasord WRITE,icebuser READ"); iceb_nomnak(gko,rek.kassa.ravno(),&nomd,rek.prn,2,1,data->window); zaphkorw(0,rek.kassa.ravno(),rek.prn,dko,mko,gko,nomd.ravno(),shetk,rek.kodop.ravno(),naimop,"","","","","",0,0,0,"","",data->window); printf("%s:%s\n",gettext("Кассовый ордер"),nomd.ravno()); for(nomer_kontr=0; nomer_kontr < kod_kontr.kolih(); nomer_kontr++) { zapzkorw(rek.kassa.ravno(),rek.prn,dko,mko,gko,nomd.ravno(),kod_kontr.ravno(nomer_kontr),suma_kontr.ravno(nomer_kontr),"","",data->window); } } sprintf(strsql,"%s:%d",gettext("Количество экспортированых кассовых ордеров"),kolih_kasord); iceb_menu_soob(strsql,data->window); }
void usldoks_knopka(GtkWidget *widget,class usldoks_data *data) { short dd,md,gd; char strsql[512]; int knop=GPOINTER_TO_INT(gtk_object_get_user_data(GTK_OBJECT(widget))); data->kl_shift=0; //Сбрасываем нажатый сшифт switch (knop) { case FK2: if(data->poi.metka_pros == 1) data->poi.metka_pros=0; else data->poi.metka_pros=1; usldoks_create_list(data); return; case SFK2: if(iceb_menu_danet(gettext("Снять отметку неподтвеждённого документа ? Вы уверены ?"),2,data->window) == 2) return; sprintf(strsql,"update Usldokum \ set \ pod=1 \ where datd='%s' and podr=%d and nomd='%s' and tp=%d", data->datav.ravno_sqldata(),data->podrv.ravno_atoi(),data->nomdokv.ravno(),data->tipzv); iceb_sql_zapis(strsql,0,0,data->window); usldoks_create_list(data); return; case FK3: if(data->poi.metka_pros == 2) data->poi.metka_pros=0; else data->poi.metka_pros=2; usldoks_create_list(data); return; case SFK3: if(iceb_menu_danet(gettext("Снять отметку документа без проводок ? Вы уверены ?"),2,data->window) == 2) return; sprintf(strsql,"update Usldokum \ set \ pro=1 \ where datd='%s' and podr=%d and nomd='%s' and tp=%d", data->datav.ravno_sqldata(),data->podrv.ravno_atoi(),data->nomdokv.ravno(),data->tipzv); iceb_sql_zapis(strsql,0,0,data->window); usldoks_create_list(data); return; case FK4: l_usldoks_p(&data->poi,data->window); if(data->poi.metka_poi == 1) { if(data->poi.datan.getdlinna() > 1) iceb_rsdatp(&data->dn,&data->mn,&data->gn,data->poi.datan.ravno(),\ &data->dk,&data->mk,&data->gk,data->poi.datak.ravno(),data->window); } else { data->dn=data->ds; data->mn=data->ms; data->gn=data->gs; } usldoks_create_list(data); return; case FK5: iceb_u_rsdat(&dd,&md,&gd,data->datav.ravno(),1); l_usldok(dd,md,gd,data->tipzv,data->podrv.ravno_atoi(),data->nomdokv.ravno(),data->window); /*При выходе из документа устанавливаются метки подтверждения и выполнения проводок*/ usldoks_create_list(data); return; case FK6: l_usldoks_eko(data); return; case FK9: data->poi.metka_opl++; if(data->poi.metka_opl > 2) data->poi.metka_opl=0; usldoks_create_list(data); return; case FK10: // printf("usldoks_knopka F10\n"); gtk_widget_destroy(data->window); return; } }
static gboolean randomize_dialog (GimpDrawable *drawable) { GtkWidget *dlg; GtkWidget *table; GtkWidget *label; GtkWidget *seed_hbox; GtkWidget *main_vbox; GtkWidget *preview; GtkObject *adj; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dlg = gimp_dialog_new (gettext (RNDM_NAME[rndm_type - 1]), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC[rndm_type - 1], GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dlg)); main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), main_vbox, TRUE, TRUE, 0); gtk_widget_show (main_vbox); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (randomize), drawable); table = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_set_border_width (GTK_CONTAINER (table), 12); gtk_box_pack_start (GTK_BOX (main_vbox), table, TRUE, TRUE, 0); gtk_widget_show(table); /* Random Seed */ seed_hbox = gimp_random_seed_new (&pivals.seed, &pivals.randomize); label = gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("_Random seed:"), 0.0, 0.5, seed_hbox, 1, TRUE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), GIMP_RANDOM_SEED_SPINBUTTON (seed_hbox)); /* * Randomization percentage label & scale (1 to 100) */ adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("R_andomization (%):"), SCALE_WIDTH, 0, pivals.rndm_pct, 1.0, 100.0, 1.0, 10.0, 0, TRUE, 0, 0, _("Percentage of pixels to be filtered"), NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &pivals.rndm_pct); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); /* * Repeat count label & scale (1 to 100) */ adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2, _("R_epeat:"), SCALE_WIDTH, 0, pivals.rndm_rcount, 1.0, 100.0, 1.0, 10.0, 0, TRUE, 0, 0, _("Number of times to apply filter"), NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_double_adjustment_update), &pivals.rndm_rcount); g_signal_connect_swapped (adj, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (dlg); run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK); gtk_widget_destroy (dlg); return run; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { GimpDrawable *drawable; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; /* assume the best! */ static GimpParam values[1]; INIT_I18N (); /* * Get the specified drawable, do standard initialization. */ if (strcmp (name, PLUG_IN_PROC[0]) == 0) rndm_type = RNDM_HURL; else if (strcmp (name, PLUG_IN_PROC[1]) == 0) rndm_type = RNDM_PICK; else if (strcmp (name, PLUG_IN_PROC[2]) == 0) rndm_type = RNDM_SLUR; run_mode = param[0].data.d_int32; drawable = gimp_drawable_get(param[2].data.d_drawable); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; gr = g_rand_new (); /* * Make sure the drawable type is appropriate. */ if (gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id) || gimp_drawable_is_indexed (drawable->drawable_id)) { gimp_tile_cache_ntiles (2 * drawable->ntile_cols); switch (run_mode) { /* * If we're running interactively, pop up the dialog box. */ case GIMP_RUN_INTERACTIVE: gimp_get_data (PLUG_IN_PROC[rndm_type - 1], &pivals); if (! randomize_dialog (drawable)) /* return on Cancel */ return; break; /* * If we're not interactive (probably scripting), we * get the parameters from the param[] array, since * we don't use the dialog box. Make sure they all * parameters have legitimate values. */ case GIMP_RUN_NONINTERACTIVE: if (nparams != 7) { status = GIMP_PDB_CALLING_ERROR; } else { pivals.rndm_pct = (gdouble) param[3].data.d_float; pivals.rndm_rcount = (gdouble) param[4].data.d_float; pivals.randomize = (gboolean) param[5].data.d_int32; pivals.seed = (gint) param[6].data.d_int32; if (pivals.randomize) pivals.seed = g_random_int (); if ((rndm_type != RNDM_PICK && rndm_type != RNDM_SLUR && rndm_type != RNDM_HURL) || (pivals.rndm_pct < 1.0 || pivals.rndm_pct > 100.0) || (pivals.rndm_rcount < 1.0 || pivals.rndm_rcount > 100.0)) { status = GIMP_PDB_CALLING_ERROR; } } break; /* * If we're running with the last set of values, get those values. */ case GIMP_RUN_WITH_LAST_VALS: gimp_get_data (PLUG_IN_PROC[rndm_type - 1], &pivals); if (pivals.randomize) pivals.seed = g_random_int (); break; /* * Hopefully we never get here! */ default: break; } if (status == GIMP_PDB_SUCCESS) { gimp_progress_init_printf ("%s", gettext (RNDM_NAME[rndm_type - 1])); /* * Initialize the g_rand() function seed */ g_rand_set_seed (gr, pivals.seed); randomize (drawable, NULL); /* * If we ran interactively (even repeating) update the display. */ if (run_mode != GIMP_RUN_NONINTERACTIVE) { gimp_displays_flush (); } /* * If we use the dialog popup, set the data for future use. */ if (run_mode == GIMP_RUN_INTERACTIVE) { gimp_set_data (PLUG_IN_PROC[rndm_type - 1], &pivals, sizeof (RandomizeVals)); } } } else { /* * If we got the wrong drawable type, we need to complain. */ status = GIMP_PDB_EXECUTION_ERROR; } /* * DONE! * Set the status where GIMP can see it, and let go * of the drawable. */ g_rand_free (gr); values[0].data.d_status = status; gimp_drawable_detach(drawable); }
int ScilabGateway::addToClasspath(char * fname, const int envId, void * pvApiCtx) { SciErr err; int * addr = 0; int rows; int cols; char ** className = 0; CheckInputArgumentAtLeast(pvApiCtx, 1); CheckOutputArgument(pvApiCtx, 1, 1); ScilabAbstractEnvironment & env = ScilabEnvironments::getEnvironment(envId); ScilabGatewayOptions & options = env.getGatewayOptions(); OptionsHelper::setCopyOccurred(false); ScilabObjects::initialization(env, pvApiCtx); options.setIsNew(false); for (int i = 1; i <= Rhs; i++) { err = getVarAddressFromPosition(pvApiCtx, i, &addr); if (err.iErr) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data")); } if (!isStringType(pvApiCtx, addr)) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Wrong type for argument #%d: A string expected."), 1); } if (getAllocatedMatrixOfString(pvApiCtx, addr, &rows, &cols, &className)) { throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Invalid variable: cannot retrieve the data")); } for (int j = 0; j < rows * cols; j++) { char * expandedPath = expandPathVariable(const_cast<char *>(className[j])); if (expandedPath) { try { env.addtoclasspath(expandedPath); } catch (std::exception & e) { FREE(expandedPath); freeAllocatedMatrixOfString(rows, cols, className); throw; } FREE(expandedPath); } else { std::string str(className[j]); freeAllocatedMatrixOfString(rows, cols, className); throw ScilabAbstractEnvironmentException(__LINE__, __FILE__, gettext("Cannot open the given file %s."), str.c_str()); } } freeAllocatedMatrixOfString(rows, cols, className); className = 0; } LhsVar(1) = 0; PutLhsVar(); return 0; }
int admin_user_p(class admin_user_poi *rek_poi,GtkWidget *wpredok) { class admin_user_p_data data; char strsql[512]; data.rk=rek_poi; data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); sprintf(strsql,"%s %s",name_system,gettext("Поиск")); gtk_window_set_title(GTK_WINDOW(data.window),strsql); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(admin_user_p_key_press),&data); if(wpredok != NULL) { gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok)); } //Закрыть окно если окно предок удалено gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE); GtkWidget *vbox = gtk_vbox_new (FALSE, 0); GtkWidget *hbox[KOLENTER]; for(int i=0; i < KOLENTER; i++) hbox[i] = gtk_hbox_new (FALSE, 0); GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (data.window), vbox); for(int i=0; i < KOLENTER; i++) gtk_box_pack_start (GTK_BOX (vbox),hbox[i], TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), hboxknop, TRUE, TRUE, 0); GtkWidget *label=gtk_label_new(gettext("Логин")); gtk_box_pack_start (GTK_BOX (hbox[E_LOGIN]), label, FALSE, FALSE, 0); data.entry[E_LOGIN] = gtk_entry_new(); gtk_box_pack_start (GTK_BOX (hbox[E_LOGIN]), data.entry[E_LOGIN], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_LOGIN]), "activate",GTK_SIGNAL_FUNC(admin_user_p_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_LOGIN]),data.rk->login.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_LOGIN]),(gpointer)E_LOGIN); label=gtk_label_new(gettext("Имя базы данных")); gtk_box_pack_start (GTK_BOX (hbox[E_IMABAZ]), label, FALSE, FALSE, 0); data.entry[E_IMABAZ] = gtk_entry_new(); gtk_box_pack_start (GTK_BOX (hbox[E_IMABAZ]), data.entry[E_IMABAZ], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_IMABAZ]), "activate",GTK_SIGNAL_FUNC(admin_user_p_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_IMABAZ]),data.rk->imabaz.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_IMABAZ]),(gpointer)E_IMABAZ); label=gtk_label_new(gettext("Хост на базу")); gtk_box_pack_start (GTK_BOX (hbox[E_HOST]), label, FALSE, FALSE, 0); data.entry[E_HOST] = gtk_entry_new(); gtk_box_pack_start (GTK_BOX (hbox[E_HOST]), data.entry[E_HOST], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_HOST]), "activate",GTK_SIGNAL_FUNC(admin_user_p_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_HOST]),data.rk->host.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_HOST]),(gpointer)E_HOST); GtkTooltips *tooltips[KOL_FK]; sprintf(strsql,"F2 %s",gettext("Поиск")); data.knopka[FK2]=gtk_button_new_with_label(strsql); tooltips[FK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Начать поиск нужных записей"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(admin_user_p_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE, 0); sprintf(strsql,"F4 %s",gettext("Очистить")); data.knopka[FK4]=gtk_button_new_with_label(strsql); tooltips[FK4]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Очистить меню от введеноой информации"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]),"clicked",GTK_SIGNAL_FUNC(admin_user_p_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK4], TRUE, TRUE, 0); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka[FK10]=gtk_button_new_with_label(strsql); tooltips[FK10]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Поиск не выполнять"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(admin_user_p_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE, 0); gtk_widget_grab_focus(data.entry[0]); gtk_widget_show_all (data.window); gtk_main(); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); return(data.voz); }
/*************************** * * * Encodings dialog window * * * **************************/ void gxi_edit_encodings_clicked_cb (GtkButton *button, GncXmlImportData *data) { GtkBuilder *builder; GtkWidget *dialog; GtkListStore *list_store; GtkTreeStore *tree_store; GtkTreeIter iter, parent, *parent_ptr; GList *encodings_bak, *enc_iter; const gchar *encoding; system_encoding_type *system_enc; gpointer enc_ptr; gint i, j; builder = gtk_builder_new(); gnc_builder_add_from_file (builder, "assistant-xml-encoding.glade", "encodings_dialog"); dialog = GTK_WIDGET(gtk_builder_get_object (builder, "encodings_dialog")); data->encodings_dialog = dialog; // Set the style context for this assistant so it can be easily manipulated with css gnc_widget_set_style_context (GTK_WIDGET(dialog), "GncAssistXmlEncoding"); gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, data); gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (data->assistant)); data->available_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "available_encs_view")); data->custom_enc_entry = GTK_WIDGET(gtk_builder_get_object (builder, "custom_enc_entry")); /* set up selected encodings list */ data->selected_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "selected_encs_view")); list_store = gtk_list_store_new (ENC_NUM_COLS, G_TYPE_STRING, G_TYPE_POINTER); for (enc_iter = data->encodings; enc_iter; enc_iter = enc_iter->next) { encoding = g_quark_to_string (GPOINTER_TO_UINT (enc_iter->data)); gtk_list_store_append (list_store, &iter); gtk_list_store_set (list_store, &iter, ENC_COL_STRING, encoding, ENC_COL_QUARK, enc_iter->data, -1); } gtk_tree_view_insert_column_with_attributes ( data->selected_encs_view, -1, NULL, gtk_cell_renderer_text_new (), "text", ENC_COL_STRING, NULL); gtk_tree_view_set_model (data->selected_encs_view, GTK_TREE_MODEL (list_store)); g_object_unref (list_store); /* set up system encodings list */ data->available_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "available_encs_view")); tree_store = gtk_tree_store_new (ENC_NUM_COLS, G_TYPE_STRING, G_TYPE_POINTER); for (i = 0, system_enc = system_encodings; i < n_system_encodings; i++, system_enc++) { if (i == 0) { /* first system encoding */ parent_ptr = NULL; } else { parent_ptr = &iter; for (j = 0; j < system_enc->parent; j++) if (gtk_tree_model_iter_parent (GTK_TREE_MODEL (tree_store), &parent, &iter)) { /* go up one level */ iter = parent; } else { /* no parent to toplevel element */ parent_ptr = NULL; } } if (system_enc->encoding) enc_ptr = GUINT_TO_POINTER (g_quark_from_string (system_enc->encoding)); else enc_ptr = NULL; gtk_tree_store_append (tree_store, &iter, parent_ptr); gtk_tree_store_set (tree_store, &iter, ENC_COL_STRING, gettext (system_enc->text), ENC_COL_QUARK, enc_ptr, -1); } gtk_tree_view_insert_column_with_attributes ( data->available_encs_view, -1, NULL, gtk_cell_renderer_text_new (), "text", ENC_COL_STRING, NULL); gtk_tree_view_set_model (data->available_encs_view, GTK_TREE_MODEL (tree_store)); g_object_unref (tree_store); /* run the dialog */ encodings_bak = g_list_copy (data->encodings); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) { g_list_free (encodings_bak); if (!g_list_find (data->encodings, GUINT_TO_POINTER (data->default_encoding))) { /* choose top level encoding then */ data->default_encoding = GPOINTER_TO_UINT (data->encodings->data); } /* update whole page */ gxi_check_file (data); gxi_update_default_enc_combo (data); gxi_update_string_box (data); gxi_update_conversion_forward (data); } else { g_list_free (data->encodings); data->encodings = encodings_bak; } g_object_unref(G_OBJECT(builder)); gtk_widget_destroy (dialog); data->encodings_dialog = NULL; }
void StatusWindow::update() { // Status Part // ----------- mLvlLabel->setCaption(strprintf(_("Level: %d"), mPlayer->getLevel())); mLvlLabel->adjustSize(); mJobLvlLabel->setCaption(strprintf(_("Job: %d"), mPlayer->mJobLevel)); mJobLvlLabel->adjustSize(); if (mCurrency != mPlayer->getMoney()) { mCurrency = mPlayer->getMoney(); mGpLabel->setCaption(strprintf(_("Money: %s"), Units::formatCurrency(mCurrency).c_str())); mGpLabel->adjustSize(); } updateHPBar(mHpBar, true); updateMPBar(mMpBar, true); updateXPBar(mXpBar, false); updateJobBar(mJobBar, false); // Stats Part // ---------- static const char *attrNames[6] = { N_("Strength"), N_("Agility"), N_("Vitality"), N_("Intelligence"), N_("Dexterity"), N_("Luck") }; int statusPoints = mPlayer->mStatsPointsToAttribute; // Update labels for (int i = 0; i < 6; i++) { mStatsLabel[i]->setCaption(gettext(attrNames[i])); mStatsDisplayLabel[i]->setCaption(toString((int) mPlayer->mAttr[i])); mPointsLabel[i]->setCaption(toString((int) mPlayer->mAttrUp[i])); mStatsLabel[i]->adjustSize(); mStatsDisplayLabel[i]->adjustSize(); mPointsLabel[i]->adjustSize(); mStatsButton[i]->setEnabled(mPlayer->mAttrUp[i] <= statusPoints); } mRemainingStatsPointsLabel->setCaption( strprintf(_("Remaining Status Points: %d"), statusPoints)); mRemainingStatsPointsLabel->adjustSize(); // Derived Stats Points // Attack TODO: Count equipped Weapons and items attack bonuses mStatsAttackPoints->setCaption( toString(mPlayer->ATK + mPlayer->ATK_BONUS)); mStatsAttackPoints->adjustSize(); // Defense TODO: Count equipped Armors and items defense bonuses mStatsDefensePoints->setCaption( toString(mPlayer->DEF + mPlayer->DEF_BONUS)); mStatsDefensePoints->adjustSize(); // Magic Attack TODO: Count equipped items M.Attack bonuses mStatsMagicAttackPoints->setCaption( toString(mPlayer->MATK + mPlayer->MATK_BONUS)); mStatsMagicAttackPoints->adjustSize(); // Magic Defense TODO: Count equipped items M.Defense bonuses mStatsMagicDefensePoints->setCaption( toString(mPlayer->MDEF + mPlayer->MDEF_BONUS)); mStatsMagicDefensePoints->adjustSize(); // Accuracy % mStatsAccuracyPoints->setCaption(toString(mPlayer->HIT)); mStatsAccuracyPoints->adjustSize(); // Evasion % mStatsEvadePoints->setCaption(toString(mPlayer->FLEE)); mStatsEvadePoints->adjustSize(); // Reflex % mStatsReflexPoints->setCaption(toString(mPlayer->DEX / 4)); // + counter mStatsReflexPoints->adjustSize(); }
// Message Box Replacement int WINAPI MessageBoxX(LPCTSTR lpText, LPCTSTR lpCaption, UINT uType) { WndForm *wf=NULL; WndFrame *wText=NULL; int X, Y, Width, Height; WndButton *wButtons[10]; int ButtonCount = 0; int i,x,y,d,w,h,res,dY; RECT rc; // todo assert(lpText != NULL); assert(lpCaption != NULL); // JMW this makes the first key if pressed quickly, ignored XCSoarInterface::Debounce(); rc = XCSoarInterface::main_window.get_position(); #ifdef ALTAIRSYNC Width = DLGSCALE(220); Height = DLGSCALE(160); #else Width = DLGSCALE(200); Height = DLGSCALE(160); #endif X = ((rc.right-rc.left) - Width)/2; Y = ((rc.bottom-rc.top) - Height)/2; y = DLGSCALE(100); w = DLGSCALE(60); h = DLGSCALE(32); wf = new WndForm(&XCSoarInterface::main_window, TEXT("frmXcSoarMessageDlg"), lpCaption, X, Y, Width, Height); wf->SetFont(MapWindowBoldFont); wf->SetTitleFont(MapWindowBoldFont); wf->SetBackColor(Color(0xDA, 0xDB, 0xAB)); wText = new WndFrame(wf, TEXT("frmMessageDlgText"), 0, DLGSCALE(5), Width, Height); wText->SetCaption(lpText); wText->SetFont(MapWindowBoldFont); wText->SetCaptionStyle( DT_EXPANDTABS | DT_CENTER | DT_NOCLIP | DT_WORDBREAK // | DT_VCENTER ); /* TODO code: this doesnt work to set font height dY = wText->GetLastDrawTextHeight() - Height; */ dY = DLGSCALE(-40); wText->SetHeight(wText->GetTextHeight() + 5); wf->SetHeight(wf->GetHeight() + dY); y += dY; uType = uType & 0x000f; if (uType == MB_OK || uType == MB_OKCANCEL ) { wButtons[ButtonCount] = new WndButton(wf, TEXT(""), gettext(TEXT("OK")), 0, y, w, h, OnButtonClick); wButtons[ButtonCount]->SetTag(IDOK); ButtonCount++; } if (uType == MB_YESNO || uType == MB_YESNOCANCEL ) { wButtons[ButtonCount] = new WndButton(wf, TEXT(""), gettext(TEXT("Yes")), 0, y, w, h, OnButtonClick); wButtons[ButtonCount]->SetTag(IDYES); ButtonCount++; wButtons[ButtonCount] = new WndButton(wf, TEXT(""), gettext(TEXT("No")), 0, y, w, h, OnButtonClick); wButtons[ButtonCount]->SetTag(IDNO); ButtonCount++; } if (uType == MB_ABORTRETRYIGNORE || uType == MB_RETRYCANCEL ) { wButtons[ButtonCount] = new WndButton(wf, TEXT(""), gettext(TEXT("Retry")), 0, y, w, h, OnButtonClick); wButtons[ButtonCount]->SetTag(IDRETRY); ButtonCount++; } if (uType == MB_OKCANCEL || uType == MB_RETRYCANCEL || uType == MB_YESNOCANCEL ) { wButtons[ButtonCount] = new WndButton(wf, TEXT(""), gettext(TEXT("Cancel")), 0, y, w, h, OnButtonClick); wButtons[ButtonCount]->SetTag(IDCANCEL); ButtonCount++; } if (uType == MB_ABORTRETRYIGNORE ) { wButtons[ButtonCount] = new WndButton(wf, TEXT(""), gettext(TEXT("Abort")), 0, y, w, h, OnButtonClick); wButtons[ButtonCount]->SetTag(IDABORT); ButtonCount++; wButtons[ButtonCount] = new WndButton(wf, TEXT(""), gettext(TEXT("Ignore")), 0, y, w, h, OnButtonClick); wButtons[ButtonCount]->SetTag(IDIGNORE); ButtonCount++; } d = Width / (ButtonCount); x = d/2-w/2; for (i=0; i<ButtonCount; i++) { wButtons[i]->SetLeft(x); x += d; } res = wf->ShowModal(); delete wf; #ifdef ALTAIRSYNC // force a refresh of the window behind InvalidateRect(hWnd,NULL,true); UpdateWindow(hWnd); #endif return(res); }
const char *Singleton::Translator::getText(const char *aStringToTranslate) { return gettext(aStringToTranslate); }
/* * Function: iposecFunc() * * Arguments: char *configFile, char *Section, char *Label, int command * int argc, char *argv[] * Description: This function verifys the ipsec properties. * * Returns: int */ static int ipsecFunc(char *configFile, char *Section, char *Label, int command, int argc, char *argv[]) { char buffer[MAX_VALUE_LEN], pbuf[MAX_VALUE_LEN] = "", *policy, *policyP; int rc, LabelExists; extern char *validIPsecAction[]; /* Check to see if label already exists */ rc = GetPrivateProfileString(Section, Label, "", buffer, MAX_VALUE_LEN-1, configFile); if (!rc) LabelExists = TRUE; else LabelExists = FALSE; /* * mipagentconfig differs from mipagent here in that the configuration * is broken into argv[]'s, where as when we read this in mipagent it * comes in one string. For the sake of common code, we put all the * argv[]'s into one buffer */ for (rc = 0; rc < argc; rc++) { (void) strcat(pbuf, argv[rc]); (void) strcat(pbuf, " "); } switch (command) { case Add: /* what are we adding? */ if (argc < 2) { /* * Must have at least "<action> {<property>}" = 2. * Then again, "<action> {<<tag> <alg>>} = 3... */ (void) fprintf(stderr, gettext("Error: IPsec policy is incomplete. " "Please specify the complete IPsec policy. " "See ipsec(7p).\n")); return (-1); } if (LabelExists) { (void) fprintf(stderr, gettext("Error: %s is already configured in [%s]:\n" "\t%s = %s\n"), Label, Section, Label, buffer); return (-1); } /* * Determine if this is a valid policy. Note: we have to do * this one IPsec Policy at a time. */ policy = strdup(pbuf); policyP = policy; /* strtok() is destructive */ while ((policy = strtok(policy, IPSP_SEPARATOR)) != NULL) { if (isIPsecPolicyValid(policy, NULL) != TRUE) { (void) fprintf(stderr, gettext("Error: policy %s is not valid " "Policy may only contain <"), policy); (void) printValidStrings(validIPsecAction); (void) fprintf(stderr, gettext("> as actions, and valid IPsec" "<properties>. See ipsec(7P).\n")); return (-1); } policy = NULL; } free(policyP); /* Checks out, so add it */ rc = WritePrivateProfileString(Section, Label, pbuf, configFile); if (rc) { (void) fprintf(stderr, "%s\n", ErrorString); return (rc); } return (0); case Delete: if (!LabelExists) { (void) fprintf(stderr, gettext("Error: %s is not configured in [%s].\n"), Label, Section); return (-1); } rc = DeletePrivateProfileLabel(Section, Label, configFile); if (rc) (void) fprintf(stderr, "%s\n", ErrorString); return (rc); case Change: if (argc < 2) { /* must have at least "<action> {<properties>}" = 2 */ (void) fprintf(stderr, gettext("Error: IPsec Policy incomplete. " "Please specify the complete new IPsec Policy. " "See ipsec(7P).\n")); return (-1); } if (!LabelExists) { (void) fprintf(stderr, gettext("Error: %s is not configured in [%s].\n"), Label, Section); return (-1); } /* * Is the format of this setting valid? Note: we have to do * this one IPsec Policy at a time. */ policy = strdup(pbuf); policyP = policy; /* strtok() is destructive */ while ((policy = strtok(policy, IPSP_SEPARATOR)) != NULL) { if (isIPsecPolicyValid(policy, NULL) != TRUE) { (void) fprintf(stderr, gettext("Error: %s is not a valid IPsec " "policy. Policy may only contain <"), policy); (void) printValidStrings(validIPsecAction); (void) fprintf(stderr, gettext("> as actions, and valid IPsec " "<properties>. See ipsec(7P).\n")); return (-1); } policy = NULL; } free(policyP); /* Checks out, so change it */ rc = WritePrivateProfileString(Section, Label, pbuf, configFile); if (rc) { (void) fprintf(stderr, "%s\n", ErrorString); return (rc); } return (0); case Get: if (!LabelExists) { (void) fprintf(stderr, gettext("Error: %s is not configigured in [%s].\n"), Label, Section); return (-1); } (void) printf(gettext("[%s]\n\t%s = %s\n"), Section, Label, buffer); return (0); default: (void) fprintf(stderr, gettext("Error: Invalid command code!\n")); return (-1); } /* switch (command) */ } /* ipsecFunc */
const QString Singleton::Translator::getText(const QString &aStringToTranslate) { return gettext(ASCII(aStringToTranslate)); }
static int LYLoadCGI(const char *arg, HTParentAnchor *anAnchor, HTFormat format_out, HTStream *sink) { int status = 0; #ifdef LYNXCGI_LINKS #ifndef VMS char *cp; struct stat stat_buf; char *pgm = NULL; /* executable */ char *pgm_args = NULL; /* and its argument(s) */ int statrv; char *orig_pgm = NULL; /* Path up to ? as given, URL-escaped */ char *document_root = NULL; /* Corrected value of DOCUMENT_ROOT */ char *path_info = NULL; /* PATH_INFO extracted from pgm */ char *pgm_buff = NULL; /* PATH_INFO extraction buffer */ char *path_translated; /* From document_root/path_info */ if (isEmpty(arg) || strlen(arg) <= 8) { HTAlert(BAD_REQUEST); status = -2; return (status); } else { if (StrNCmp(arg, "lynxcgi://localhost", 19) == 0) { StrAllocCopy(pgm, arg + 19); } else { StrAllocCopy(pgm, arg + 8); } if ((cp = StrChr(pgm, '?')) != NULL) { /* Need to terminate executable */ *cp++ = '\0'; pgm_args = cp; } } StrAllocCopy(orig_pgm, pgm); if (trimPoundSelector(pgm) != NULL) { /* * Strip a #fragment from path. In this case any pgm_args found above * will also be bogus, since the '?' came after the '#' and is part of * the fragment. Note that we don't handle the case where a '#' * appears after a '?' properly according to URL rules. - kw */ pgm_args = NULL; } HTUnEscape(pgm); /* BEGIN WebSter Mods */ /* If pgm is not stat-able, see if PATH_INFO data is at the end of pgm */ if ((statrv = stat(pgm, &stat_buf)) < 0) { StrAllocCopy(pgm_buff, pgm); while (statrv < 0 || (statrv = stat(pgm_buff, &stat_buf)) < 0) { if ((cp = strrchr(pgm_buff, '/')) != NULL) { *cp = '\0'; statrv = 1; /* force new stat() - kw */ } else { PERROR("strrchr(pgm_buff, '/') returned NULL"); break; } } if (statrv < 0) { /* Did not find PATH_INFO data */ PERROR("stat() of pgm_buff failed"); } else { /* Found PATH_INFO data. Strip it off of pgm and into path_info. */ StrAllocCopy(path_info, pgm + strlen(pgm_buff)); /* The following is safe since pgm_buff was derived from pgm by stripping stuff off its end and by HTUnEscaping, so we know we have enough memory allocated for pgm. Note that pgm_args may still point into that memory, so we cannot reallocate pgm here. - kw */ strcpy(pgm, pgm_buff); CTRACE((tfp, "LYNXCGI: stat() of %s succeeded, path_info=\"%s\".\n", pgm_buff, path_info)); } FREE(pgm_buff); } /* END WebSter Mods */ if (statrv != 0) { /* * Neither the path as given nor any components examined by backing up * were stat()able. - kw */ HTAlert(gettext("Unable to access cgi script")); PERROR("stat() failed"); status = -4; } else #ifdef _WINDOWS /* 1998/01/14 (Wed) 09:16:04 */ #define isExecutable(mode) (mode & (S_IXUSR)) #else #define isExecutable(mode) (mode & (S_IXUSR|S_IXGRP|S_IXOTH)) #endif if (!(S_ISREG(stat_buf.st_mode) && isExecutable(stat_buf.st_mode))) { /* * Not a runnable file, See if we can load it using "file:" code. */ char *new_arg = NULL; /* * But try "file:" only if the file we are looking at is the path as * given (no path_info was extracted), otherwise it will be to * confusing to know just what file is loaded. - kw */ if (path_info) { CTRACE((tfp, "%s is not a file and %s not an executable, giving up.\n", orig_pgm, pgm)); FREE(path_info); FREE(pgm); FREE(orig_pgm); status = -4; return (status); } LYLocalFileToURL(&new_arg, orig_pgm); CTRACE((tfp, "%s is not an executable file, passing the buck.\n", arg)); status = HTLoadFile(new_arg, anAnchor, format_out, sink); FREE(new_arg); } else if (path_info && anAnchor != HTMainAnchor && !(reloading && anAnchor->document) && strcmp(arg, HTLoadedDocumentURL()) && HText_AreDifferent(anAnchor, arg) && HTUnEscape(orig_pgm) && !can_exec_cgi(orig_pgm, "")) { /* * If we have extra path info and are not just reloading the current, * check the full file path (after unescaping) now to catch forbidden * segments. - kw */ status = HT_NOT_LOADED; } else if (no_lynxcgi) { HTUserMsg(CGI_DISABLED); status = HT_NOT_LOADED; } else if (no_bookmark_exec && anAnchor != HTMainAnchor && !(reloading && anAnchor->document) && strcmp(arg, HTLoadedDocumentURL()) && HText_AreDifferent(anAnchor, arg) && HTLoadedDocumentBookmark()) { /* * If we are reloading a lynxcgi document that had already been loaded, * the various checks above should allow it even if no_bookmark_exec is * TRUE an we are not now coming from a bookmark page. - kw */ HTUserMsg(BOOKMARK_EXEC_DISABLED); status = HT_NOT_LOADED; } else if (anAnchor != HTMainAnchor && !(reloading && anAnchor->document) && strcmp(arg, HTLoadedDocumentURL()) && HText_AreDifferent(anAnchor, arg) && !can_exec_cgi(pgm, pgm_args)) { /* * If we are reloading a lynxcgi document that had already been loaded, * the various checks above should allow it even if exec_ok() would * reject it because we are not now coming from a document with a URL * allowed by TRUSTED_LYNXCGI rules. - kw */ status = HT_NOT_LOADED; } else { HTFormat format_in; HTStream *target = NULL; /* Unconverted data */ int fd1[2], fd2[2]; char buf[MAX_LINE]; int pid; #ifdef HAVE_TYPE_UNIONWAIT union wait wstatus; #else int wstatus; #endif fd1[0] = -1; fd1[1] = -1; fd2[0] = -1; fd2[1] = -1; if (anAnchor->isHEAD || keep_mime_headers) { /* Show output as plain text */ format_in = WWW_PLAINTEXT; } else { /* Decode full HTTP response */ format_in = HTAtom_for("www/mime"); } target = HTStreamStack(format_in, format_out, sink, anAnchor); if (!target || target == NULL) { char *tmp = 0; HTSprintf0(&tmp, CANNOT_CONVERT_I_TO_O, HTAtom_name(format_in), HTAtom_name(format_out)); HTAlert(tmp); FREE(tmp); status = HT_NOT_LOADED; } else if (anAnchor->post_data && pipe(fd1) < 0) { HTAlert(CONNECT_SET_FAILED); PERROR("pipe() failed"); status = -3; } else if (pipe(fd2) < 0) { HTAlert(CONNECT_SET_FAILED); PERROR("pipe() failed"); close(fd1[0]); close(fd1[1]); status = -3; } else { static BOOL first_time = TRUE; /* One time setup flag */ if (first_time) { /* Set up static environment variables */ first_time = FALSE; /* Only once */ add_environment_value("REMOTE_HOST=localhost"); add_environment_value("REMOTE_ADDR=127.0.0.1"); HTSprintf0(&user_agent, "HTTP_USER_AGENT=%s/%s libwww/%s", LYNX_NAME, LYNX_VERSION, HTLibraryVersion); add_environment_value(user_agent); HTSprintf0(&server_software, "SERVER_SOFTWARE=%s/%s", LYNX_NAME, LYNX_VERSION); add_environment_value(server_software); } fflush(stdout); fflush(stderr); CTRACE_FLUSH(tfp); if ((pid = fork()) > 0) { /* The good, */ ssize_t chars; off_t total_chars; close(fd2[1]); if (anAnchor->post_data) { ssize_t written; int remaining, total_written = 0; close(fd1[0]); /* We have form data to push across the pipe */ if (TRACE) { CTRACE((tfp, "LYNXCGI: Doing post, content-type '%s'\n", anAnchor->post_content_type)); CTRACE((tfp, "LYNXCGI: Writing:\n")); trace_bstring(anAnchor->post_data); CTRACE((tfp, "----------------------------------\n")); } remaining = BStrLen(anAnchor->post_data); while ((written = write(fd1[1], BStrData(anAnchor->post_data) + total_written, (size_t) remaining)) != 0) { if (written < 0) { #ifdef EINTR if (errno == EINTR) continue; #endif /* EINTR */ #ifdef ERESTARTSYS if (errno == ERESTARTSYS) continue; #endif /* ERESTARTSYS */ PERROR("write() of POST data failed"); break; } CTRACE((tfp, "LYNXCGI: Wrote %d bytes of POST data.\n", (int) written)); total_written += (int) written; remaining -= (int) written; if (remaining == 0) break; } if (remaining != 0) { CTRACE((tfp, "LYNXCGI: %d bytes remain unwritten!\n", remaining)); } close(fd1[1]); } HTReadProgress(total_chars = 0, (off_t) 0); while ((chars = read(fd2[0], buf, sizeof(buf))) != 0) { if (chars < 0) { #ifdef EINTR if (errno == EINTR) continue; #endif /* EINTR */ #ifdef ERESTARTSYS if (errno == ERESTARTSYS) continue; #endif /* ERESTARTSYS */ PERROR("read() of CGI output failed"); break; } total_chars += (int) chars; HTReadProgress(total_chars, (off_t) 0); CTRACE((tfp, "LYNXCGI: Rx: %.*s\n", (int) chars, buf)); (*target->isa->put_block) (target, buf, (int) chars); } if (chars < 0 && total_chars == 0) { status = HT_NOT_LOADED; (*target->isa->_abort) (target, NULL); target = NULL; } else if (chars != 0) { status = HT_PARTIAL_CONTENT; } else { status = HT_LOADED; } #ifndef HAVE_WAITPID while (wait(&wstatus) != pid) ; /* do nothing */ #else while (-1 == waitpid(pid, &wstatus, 0)) { /* wait for child */ #ifdef EINTR if (errno == EINTR) continue; #endif /* EINTR */ #ifdef ERESTARTSYS if (errno == ERESTARTSYS) continue; #endif /* ERESTARTSYS */ break; } #endif /* !HAVE_WAITPID */ close(fd2[0]); } else if (pid == 0) { /* The Bad, */ char **argv = NULL; int argv_cnt = 3; /* name, one arg and terminator */ char **cur_argv = NULL; int exec_errno; /* Set up output pipe */ close(fd2[0]); dup2(fd2[1], fileno(stdout)); /* Should check success code */ dup2(fd2[1], fileno(stderr)); close(fd2[1]); if (non_empty(language)) { HTSprintf0(&accept_language, "HTTP_ACCEPT_LANGUAGE=%s", language); add_environment_value(accept_language); } if (non_empty(pref_charset)) { cp = NULL; StrAllocCopy(cp, "HTTP_ACCEPT_CHARSET="); StrAllocCat(cp, pref_charset); add_environment_value(cp); } if (anAnchor->post_data && anAnchor->post_content_type) { cp = NULL; StrAllocCopy(cp, "CONTENT_TYPE="); StrAllocCat(cp, anAnchor->post_content_type); add_environment_value(cp); } if (anAnchor->post_data) { /* post script, read stdin */ close(fd1[1]); dup2(fd1[0], fileno(stdin)); close(fd1[0]); /* Build environment variables */ add_environment_value("REQUEST_METHOD=POST"); HTSprintf0(&post_len, "CONTENT_LENGTH=%d", BStrLen(anAnchor->post_data)); add_environment_value(post_len); } else { close(fileno(stdin)); if (anAnchor->isHEAD) { add_environment_value("REQUEST_METHOD=HEAD"); } } /* * Set up argument line, mainly for <index> scripts */ if (pgm_args != NULL) { for (cp = pgm_args; *cp != '\0'; cp++) { if (*cp == '+') { argv_cnt++; } } } argv = (char **) malloc((unsigned) argv_cnt * sizeof(char *)); if (argv == NULL) { outofmem(__FILE__, "LYCgi"); } assert(argv != NULL); cur_argv = argv + 1; /* For argv[0] */ if (pgm_args != NULL) { char *cr; /* Data for a get/search form */ if (is_www_index) { add_environment_value("REQUEST_METHOD=SEARCH"); } else if (!anAnchor->isHEAD && !anAnchor->post_data) { add_environment_value("REQUEST_METHOD=GET"); } cp = NULL; StrAllocCopy(cp, "QUERY_STRING="); StrAllocCat(cp, pgm_args); add_environment_value(cp); /* * Split up arguments into argv array */ cp = pgm_args; cr = cp; while (1) { if (*cp == '\0') { *(cur_argv++) = HTUnEscape(cr); break; } else if (*cp == '+') { *cp++ = '\0'; *(cur_argv++) = HTUnEscape(cr); cr = cp; } cp++; } } else if (!anAnchor->isHEAD && !anAnchor->post_data) { add_environment_value("REQUEST_METHOD=GET"); } *cur_argv = NULL; /* Terminate argv */ argv[0] = pgm; /* Begin WebSter Mods -jkt */ if (LYCgiDocumentRoot != NULL) { /* Add DOCUMENT_ROOT to env */ cp = NULL; StrAllocCopy(cp, "DOCUMENT_ROOT="); StrAllocCat(cp, LYCgiDocumentRoot); add_environment_value(cp); } if (path_info != NULL) { /* Add PATH_INFO to env */ cp = NULL; StrAllocCopy(cp, "PATH_INFO="); StrAllocCat(cp, path_info); add_environment_value(cp); } if (LYCgiDocumentRoot != NULL && path_info != NULL) { /* Construct and add PATH_TRANSLATED to env */ StrAllocCopy(document_root, LYCgiDocumentRoot); LYTrimHtmlSep(document_root); path_translated = document_root; StrAllocCat(path_translated, path_info); cp = NULL; StrAllocCopy(cp, "PATH_TRANSLATED="); StrAllocCat(cp, path_translated); add_environment_value(cp); FREE(path_translated); } /* End WebSter Mods -jkt */ execve(argv[0], argv, env); exec_errno = errno; PERROR("execve failed"); printf("Content-Type: text/plain\r\n\r\n"); if (!anAnchor->isHEAD) { printf("exec of %s failed", pgm); printf(": %s.\r\n", LYStrerror(exec_errno)); } fflush(stdout); fflush(stderr); _exit(1); } else { /* and the Ugly */ HTAlert(CONNECT_FAILED); PERROR("fork() failed"); close(fd1[0]); close(fd1[1]); close(fd2[0]); close(fd2[1]); status = -1; } } if (target != NULL) { (*target->isa->_free) (target); } } FREE(path_info); FREE(pgm); FREE(orig_pgm); #else /* VMS */ HTStream *target; char *buf = 0; target = HTStreamStack(WWW_HTML, format_out, sink, anAnchor); HTSprintf0(&buf, "<html>\n<head>\n<title>%s</title>\n</head>\n<body>\n", gettext("Good Advice")); PUTS(buf); HTSprintf0(&buf, "<h1>%s</h1>\n", gettext("Good Advice")); PUTS(buf); HTSprintf0(&buf, "%s <a\n", gettext("An excellent http server for VMS is available via")); PUTS(buf); HTSprintf0(&buf, "href=\"http://www.ecr6.ohio-state.edu/www/doc/serverinfo.html\"\n"); PUTS(buf); HTSprintf0(&buf, ">%s</a>.\n", gettext("this link")); PUTS(buf); HTSprintf0(&buf, "<p>%s\n", gettext("It provides state of the art CGI script support.\n")); PUTS(buf); HTSprintf0(&buf, "</body>\n</html>\n"); PUTS(buf); (*target->isa->_free) (target); FREE(buf); status = HT_LOADED; #endif /* VMS */ #else /* LYNXCGI_LINKS */ HTUserMsg(CGI_NOT_COMPILED); status = HT_NOT_LOADED; #endif /* LYNXCGI_LINKS */ (void) arg; (void) anAnchor; (void) format_out; (void) sink; return (status); }
int main(int argc,char **argv) { nco_bool CNV_CCM_CCSM_CF; nco_bool CMD_LN_NTP_VAR=False; /* Option i */ nco_bool CMD_LN_NTP_WGT=True; /* Option w */ nco_bool DO_CONFORM=False; /* Did nco_var_cnf_dmn() find truly conforming variables? */ nco_bool EXCLUDE_INPUT_LIST=False; /* Option c */ nco_bool EXTRACT_ALL_COORDINATES=False; /* Option c */ nco_bool EXTRACT_ASSOCIATED_COORDINATES=True; /* Option C */ nco_bool FILE_1_RETRIEVED_FROM_REMOTE_LOCATION; nco_bool FILE_2_RETRIEVED_FROM_REMOTE_LOCATION; nco_bool FIX_REC_CRD=False; /* [flg] Do not interpolate/multiply record coordinate variables */ nco_bool FL_LST_IN_FROM_STDIN=False; /* [flg] fl_lst_in comes from stdin */ nco_bool FORCE_APPEND=False; /* Option A */ nco_bool FORCE_OVERWRITE=False; /* Option O */ nco_bool FORTRAN_IDX_CNV=False; /* Option F */ nco_bool GRP_VAR_UNN=False; /* [flg] Select union of specified groups and variables */ nco_bool HISTORY_APPEND=True; /* Option h */ nco_bool MSA_USR_RDR=False; /* [flg] Multi-Slab Algorithm returns hyperslabs in user-specified order*/ nco_bool MUST_CONFORM=False; /* Must nco_var_cnf_dmn() find truly conforming variables? */ nco_bool RAM_CREATE=False; /* [flg] Create file in RAM */ nco_bool RAM_OPEN=False; /* [flg] Open (netCDF3-only) file(s) in RAM */ nco_bool RM_RMT_FL_PST_PRC=True; /* Option R */ nco_bool WRT_TMP_FL=True; /* [flg] Write output to temporary file */ nco_bool flg_cln=True; /* [flg] Clean memory prior to exit */ char **fl_lst_abb=NULL; /* Option a */ char **fl_lst_in; char **ntp_lst_in; char **grp_lst_in=NULL_CEWI; char **var_lst_in=NULL_CEWI; char *aux_arg[NC_MAX_DIMS]; char *cmd_ln; char *cnk_arg[NC_MAX_DIMS]; char *cnk_map_sng=NULL_CEWI; /* [sng] Chunking map */ char *cnk_plc_sng=NULL_CEWI; /* [sng] Chunking policy */ char *fl_in_1=NULL; /* fl_in_1 is nco_realloc'd when not NULL */ char *fl_in_2=NULL; /* fl_in_2 is nco_realloc'd when not NULL */ char *fl_out=NULL; /* Option o */ char *fl_out_tmp; char *fl_pth=NULL; /* Option p */ char *fl_pth_lcl=NULL; /* Option l */ char *lmt_arg[NC_MAX_DIMS]; char *ntp_nm=NULL; /* Option i */ char *opt_crr=NULL; /* [sng] String representation of current long-option name */ char *optarg_lcl=NULL; /* [sng] Local copy of system optarg */ char *ppc_arg[NC_MAX_VARS]; /* [sng] PPC arguments */ char *sng_cnv_rcd=NULL_CEWI; /* [sng] strtol()/strtoul() return code */ char trv_pth[]="/"; /* [sng] Root path of traversal tree */ const char * const CVS_Id="$Id$"; const char * const CVS_Revision="$Revision$"; const char * const opt_sht_lst="3467ACcD:d:Fg:G:hi:L:l:Oo:p:rRt:v:X:xw:-:"; cnk_sct cnk; /* [sct] Chunking structure */ #if defined(__cplusplus) || defined(PGI_CC) ddra_info_sct ddra_info; ddra_info.flg_ddra=False; #else /* !__cplusplus */ ddra_info_sct ddra_info={.flg_ddra=False}; #endif /* !__cplusplus */ double ntp_val_out=double_CEWI; /* Option i */ double wgt_val_1=0.5; /* Option w */ double wgt_val_2=0.5; /* Option w */ extern char *optarg; extern int optind; /* Using naked stdin/stdout/stderr in parallel region generates warning Copy appropriate filehandle to variable scoped shared in parallel clause */ FILE * const fp_stderr=stderr; /* [fl] stderr filehandle CEWI */ FILE * const fp_stdout=stdout; /* [fl] stdout filehandle CEWI */ gpe_sct *gpe=NULL; /* [sng] Group Path Editing (GPE) structure */ int *in_id_1_arr; int *in_id_2_arr; int abb_arg_nbr=0; int aux_nbr=0; /* [nbr] Number of auxiliary coordinate hyperslabs specified */ int cnk_map=nco_cnk_map_nil; /* [enm] Chunking map */ int cnk_nbr=0; /* [nbr] Number of chunk sizes */ int cnk_plc=nco_cnk_plc_nil; /* [enm] Chunking policy */ int dfl_lvl=NCO_DFL_LVL_UNDEFINED; /* [enm] Deflate level */ int fl_idx; int fl_nbr=0; int fl_in_fmt_1; /* [enm] Input file format */ int fl_in_fmt_2; /* [enm] Input file format */ int fl_out_fmt=NCO_FORMAT_UNDEFINED; /* [enm] Output file format */ int fll_md_old; /* [enm] Old fill mode */ int has_mss_val=False; int idx; int in_id_1; int in_id_2; int lmt_nbr=0; /* Option d. NB: lmt_nbr gets incremented */ int md_open; /* [enm] Mode flag for nc_open() call */ int nbr_dmn_fl; int nbr_ntp; int nbr_var_fix; /* nbr_var_fix gets incremented */ int nbr_var_fl; int nbr_var_prc; /* nbr_var_prc gets incremented */ int xtr_nbr=0; /* xtr_nbr won't otherwise be set for -c with no -v */ int opt; int out_id; int ppc_nbr=0; /* [nbr] Number of PPC arguments */ int rcd=NC_NOERR; /* [rcd] Return code */ int thr_idx; /* [idx] Index of current thread */ int thr_nbr=int_CEWI; /* [nbr] Thread number Option t */ int var_lst_in_nbr=0; int grp_lst_in_nbr=0; /* [nbr] Number of groups explicitly specified by user */ md5_sct *md5=NULL; /* [sct] MD5 configuration */ size_t bfr_sz_hnt=NC_SIZEHINT_DEFAULT; /* [B] Buffer size hint */ size_t cnk_min_byt=NCO_CNK_SZ_MIN_BYT_DFL; /* [B] Minimize size of variable to chunk */ size_t cnk_sz_byt=0UL; /* [B] Chunk size in bytes */ size_t cnk_sz_scl=0UL; /* [nbr] Chunk size scalar */ size_t hdr_pad=0UL; /* [B] Pad at end of header section */ val_unn val_gnr_unn; /* Generic container for arrival point or weight */ var_sct *wgt_1=NULL_CEWI; var_sct *wgt_2=NULL_CEWI; var_sct *wgt_out_1=NULL; var_sct *wgt_out_2=NULL; var_sct **var; var_sct **var_fix; var_sct **var_fix_out; var_sct **var_out; var_sct **var_prc_1; var_sct **var_prc_2; var_sct **var_prc_out; trv_tbl_sct *trv_tbl=NULL; /* [lst] Traversal table */ nco_dmn_dne_t *flg_dne=NULL; /* [lst] Flag to check if input dimension -d "does not exist" */ #ifdef ENABLE_MPI /* Declare all MPI-specific variables here */ MPI_Comm mpi_cmm=MPI_COMM_WORLD; /* [prc] Communicator */ int prc_rnk; /* [idx] Process rank */ int prc_nbr=0; /* [nbr] Number of MPI processes */ #endif /* !ENABLE_MPI */ static struct option opt_lng[]= { /* Structure ordered by short option key if possible */ /* Long options with no argument, no short option counterpart */ {"cln",no_argument,0,0}, /* [flg] Clean memory prior to exit */ {"clean",no_argument,0,0}, /* [flg] Clean memory prior to exit */ {"mmr_cln",no_argument,0,0}, /* [flg] Clean memory prior to exit */ {"drt",no_argument,0,0}, /* [flg] Allow dirty memory on exit */ {"dirty",no_argument,0,0}, /* [flg] Allow dirty memory on exit */ {"mmr_drt",no_argument,0,0}, /* [flg] Allow dirty memory on exit */ {"hdf4",no_argument,0,0}, /* [flg] Treat file as HDF4 */ {"hdf_upk",no_argument,0,0}, /* [flg] HDF unpack convention: unpacked=scale_factor*(packed-add_offset) */ {"hdf_unpack",no_argument,0,0}, /* [flg] HDF unpack convention: unpacked=scale_factor*(packed-add_offset) */ {"msa_usr_rdr",no_argument,0,0}, /* [flg] Multi-Slab Algorithm returns hyperslabs in user-specified order */ {"msa_user_order",no_argument,0,0}, /* [flg] Multi-Slab Algorithm returns hyperslabs in user-specified order */ {"fix_rec_crd",no_argument,0,0}, /* [flg] Do not interpolate/multiply record coordinate variables */ {"ram_all",no_argument,0,0}, /* [flg] Open (netCDF3) and create file(s) in RAM */ {"create_ram",no_argument,0,0}, /* [flg] Create file in RAM */ {"open_ram",no_argument,0,0}, /* [flg] Open (netCDF3) file(s) in RAM */ {"diskless_all",no_argument,0,0}, /* [flg] Open (netCDF3) and create file(s) in RAM */ {"wrt_tmp_fl",no_argument,0,0}, /* [flg] Write output to temporary file */ {"write_tmp_fl",no_argument,0,0}, /* [flg] Write output to temporary file */ {"no_tmp_fl",no_argument,0,0}, /* [flg] Do not write output to temporary file */ {"intersection",no_argument,0,0}, /* [flg] Select intersection of specified groups and variables */ {"nsx",no_argument,0,0}, /* [flg] Select intersection of specified groups and variables */ {"union",no_argument,0,0}, /* [flg] Select union of specified groups and variables */ {"unn",no_argument,0,0}, /* [flg] Select union of specified groups and variables */ {"version",no_argument,0,0}, {"vrs",no_argument,0,0}, /* Long options with argument, no short option counterpart */ {"bfr_sz_hnt",required_argument,0,0}, /* [B] Buffer size hint */ {"buffer_size_hint",required_argument,0,0}, /* [B] Buffer size hint */ {"cnk_byt",required_argument,0,0}, /* [B] Chunk size in bytes */ {"chunk_byte",required_argument,0,0}, /* [B] Chunk size in bytes */ {"cnk_dmn",required_argument,0,0}, /* [nbr] Chunk size */ {"chunk_dimension",required_argument,0,0}, /* [nbr] Chunk size */ {"cnk_map",required_argument,0,0}, /* [nbr] Chunking map */ {"chunk_map",required_argument,0,0}, /* [nbr] Chunking map */ {"cnk_min",required_argument,0,0}, /* [B] Minimize size of variable to chunk */ {"chunk_min",required_argument,0,0}, /* [B] Minimize size of variable to chunk */ {"cnk_plc",required_argument,0,0}, /* [nbr] Chunking policy */ {"chunk_policy",required_argument,0,0}, /* [nbr] Chunking policy */ {"cnk_scl",required_argument,0,0}, /* [nbr] Chunk size scalar */ {"chunk_scalar",required_argument,0,0}, /* [nbr] Chunk size scalar */ {"fl_fmt",required_argument,0,0}, {"file_format",required_argument,0,0}, {"hdr_pad",required_argument,0,0}, {"header_pad",required_argument,0,0}, {"ppc",required_argument,0,0}, /* [nbr] Precision-preserving compression, i.e., number of total or decimal significant digits */ {"precision_preserving_compression",required_argument,0,0}, /* [nbr] Precision-preserving compression, i.e., number of total or decimal significant digits */ {"quantize",required_argument,0,0}, /* [nbr] Precision-preserving compression, i.e., number of total or decimal significant digits */ /* Long options with short counterparts */ {"3",no_argument,0,'3'}, {"4",no_argument,0,'4'}, {"64bit",no_argument,0,'4'}, {"netcdf4",no_argument,0,'4'}, {"append",no_argument,0,'A'}, {"coords",no_argument,0,'c'}, {"crd",no_argument,0,'c'}, {"no-coords",no_argument,0,'C'}, {"no-crd",no_argument,0,'C'}, {"debug",required_argument,0,'D'}, {"nco_dbg_lvl",required_argument,0,'D'}, {"dimension",required_argument,0,'d'}, {"dmn",required_argument,0,'d'}, {"fortran",no_argument,0,'F'}, {"ftn",no_argument,0,'F'}, {"gpe",required_argument,0,'G'}, /* [sng] Group Path Edit (GPE) */ {"grp",required_argument,0,'g'}, {"group",required_argument,0,'g'}, {"history",no_argument,0,'h'}, {"hst",no_argument,0,'h'}, {"interpolate",required_argument,0,'i'}, {"ntp",required_argument,0,'i'}, {"dfl_lvl",required_argument,0,'L'}, /* [enm] Deflate level */ {"deflate",required_argument,0,'L'}, /* [enm] Deflate level */ {"local",required_argument,0,'l'}, {"lcl",required_argument,0,'l'}, {"overwrite",no_argument,0,'O'}, {"ovr",no_argument,0,'O'}, {"output",required_argument,0,'o'}, {"fl_out",required_argument,0,'o'}, {"path",required_argument,0,'p'}, {"retain",no_argument,0,'R'}, {"rtn",no_argument,0,'R'}, {"revision",no_argument,0,'r'}, {"thr_nbr",required_argument,0,'t'}, {"threads",required_argument,0,'t'}, {"omp_num_threads",required_argument,0,'t'}, {"variable",required_argument,0,'v'}, {"weight",required_argument,0,'w'}, {"wgt_var",no_argument,0,'w'}, {"auxiliary",required_argument,0,'X'}, {"exclude",no_argument,0,'x'}, {"xcl",no_argument,0,'x'}, {"help",no_argument,0,'?'}, {"hlp",no_argument,0,'?'}, {0,0,0,0} }; /* end opt_lng */ int opt_idx=0; /* Index of current long option into opt_lng array */ /* Start timer and save command line */ ddra_info.tmr_flg=nco_tmr_srt; rcd+=nco_ddra((char *)NULL,(char *)NULL,&ddra_info); ddra_info.tmr_flg=nco_tmr_mtd; cmd_ln=nco_cmd_ln_sng(argc,argv); /* Get program name and set program enum (e.g., nco_prg_id=ncra) */ nco_prg_nm=nco_prg_prs(argv[0],&nco_prg_id); #ifdef ENABLE_MPI /* MPI Initialization */ if(False) (void)fprintf(stdout,gettext("%s: WARNING Compiled with MPI\n"),nco_prg_nm); MPI_Init(&argc,&argv); MPI_Comm_size(mpi_cmm,&prc_nbr); MPI_Comm_rank(mpi_cmm,&prc_rnk); #endif /* !ENABLE_MPI */ /* Parse command line arguments */ while(1){ /* getopt_long_only() allows one dash to prefix long options */ opt=getopt_long(argc,argv,opt_sht_lst,opt_lng,&opt_idx); /* NB: access to opt_crr is only valid when long_opt is detected */ if(opt == EOF) break; /* Parse positional arguments once getopt_long() returns EOF */ opt_crr=(char *)strdup(opt_lng[opt_idx].name); /* Process long options without short option counterparts */ if(opt == 0){ if(!strcmp(opt_crr,"bfr_sz_hnt") || !strcmp(opt_crr,"buffer_size_hint")){ bfr_sz_hnt=strtoul(optarg,&sng_cnv_rcd,NCO_SNG_CNV_BASE10); if(*sng_cnv_rcd) nco_sng_cnv_err(optarg,"strtoul",sng_cnv_rcd); } /* endif cnk */ if(!strcmp(opt_crr,"cnk_byt") || !strcmp(opt_crr,"chunk_byte")){ cnk_sz_byt=strtoul(optarg,&sng_cnv_rcd,NCO_SNG_CNV_BASE10); if(*sng_cnv_rcd) nco_sng_cnv_err(optarg,"strtoul",sng_cnv_rcd); } /* endif cnk_byt */ if(!strcmp(opt_crr,"cnk_min") || !strcmp(opt_crr,"chunk_min")){ cnk_min_byt=strtoul(optarg,&sng_cnv_rcd,NCO_SNG_CNV_BASE10); if(*sng_cnv_rcd) nco_sng_cnv_err(optarg,"strtoul",sng_cnv_rcd); } /* endif cnk_min */ if(!strcmp(opt_crr,"cnk_dmn") || !strcmp(opt_crr,"chunk_dimension")){ /* Copy limit argument for later processing */ cnk_arg[cnk_nbr]=(char *)strdup(optarg); cnk_nbr++; } /* endif cnk */ if(!strcmp(opt_crr,"cnk_scl") || !strcmp(opt_crr,"chunk_scalar")){ cnk_sz_scl=strtoul(optarg,&sng_cnv_rcd,NCO_SNG_CNV_BASE10); if(*sng_cnv_rcd) nco_sng_cnv_err(optarg,"strtoul",sng_cnv_rcd); } /* endif cnk */ if(!strcmp(opt_crr,"cnk_map") || !strcmp(opt_crr,"chunk_map")){ /* Chunking map */ cnk_map_sng=(char *)strdup(optarg); cnk_map=nco_cnk_map_get(cnk_map_sng); } /* endif cnk */ if(!strcmp(opt_crr,"cnk_plc") || !strcmp(opt_crr,"chunk_policy")){ /* Chunking policy */ cnk_plc_sng=(char *)strdup(optarg); cnk_plc=nco_cnk_plc_get(cnk_plc_sng); } /* endif cnk */ if(!strcmp(opt_crr,"cln") || !strcmp(opt_crr,"mmr_cln") || !strcmp(opt_crr,"clean")) flg_cln=True; /* [flg] Clean memory prior to exit */ if(!strcmp(opt_crr,"drt") || !strcmp(opt_crr,"mmr_drt") || !strcmp(opt_crr,"dirty")) flg_cln=False; /* [flg] Clean memory prior to exit */ if(!strcmp(opt_crr,"fix_rec_crd")) FIX_REC_CRD=True; /* [flg] Do not interpolate/multiply record coordinate variables */ if(!strcmp(opt_crr,"fl_fmt") || !strcmp(opt_crr,"file_format")) rcd=nco_create_mode_prs(optarg,&fl_out_fmt); if(!strcmp(opt_crr,"hdf4")) nco_fmt_xtn=nco_fmt_xtn_hdf4; /* [enm] Treat file as HDF4 */ if(!strcmp(opt_crr,"hdf_upk") || !strcmp(opt_crr,"hdf_unpack")) nco_upk_cnv=nco_upk_HDF; /* [flg] HDF unpack convention: unpacked=scale_factor*(packed-add_offset) */ if(!strcmp(opt_crr,"hdr_pad") || !strcmp(opt_crr,"header_pad")){ hdr_pad=strtoul(optarg,&sng_cnv_rcd,NCO_SNG_CNV_BASE10); if(*sng_cnv_rcd) nco_sng_cnv_err(optarg,"strtoul",sng_cnv_rcd); } /* endif "hdr_pad" */ if(!strcmp(opt_crr,"msa_usr_rdr") || !strcmp(opt_crr,"msa_user_order")) MSA_USR_RDR=True; /* [flg] Multi-Slab Algorithm returns hyperslabs in user-specified order */ if(!strcmp(opt_crr,"ppc") || !strcmp(opt_crr,"precision_preserving_compression") || !strcmp(opt_crr,"quantize")){ ppc_arg[ppc_nbr]=(char *)strdup(optarg); ppc_nbr++; } /* endif "ppc" */ if(!strcmp(opt_crr,"ram_all") || !strcmp(opt_crr,"create_ram") || !strcmp(opt_crr,"diskless_all")) RAM_CREATE=True; /* [flg] Open (netCDF3) file(s) in RAM */ if(!strcmp(opt_crr,"ram_all") || !strcmp(opt_crr,"open_ram") || !strcmp(opt_crr,"diskless_all")) RAM_OPEN=True; /* [flg] Create file in RAM */ if(!strcmp(opt_crr,"unn") || !strcmp(opt_crr,"union")) GRP_VAR_UNN=True; if(!strcmp(opt_crr,"nsx") || !strcmp(opt_crr,"intersection")) GRP_VAR_UNN=False; if(!strcmp(opt_crr,"vrs") || !strcmp(opt_crr,"version")){ (void)nco_vrs_prn(CVS_Id,CVS_Revision); nco_exit(EXIT_SUCCESS); } /* endif "vrs" */ if(!strcmp(opt_crr,"wrt_tmp_fl") || !strcmp(opt_crr,"write_tmp_fl")) WRT_TMP_FL=True; if(!strcmp(opt_crr,"no_tmp_fl")) WRT_TMP_FL=False; } /* opt != 0 */ /* Process short options */ switch(opt){ case 0: /* Long options have already been processed, return */ break; case '3': /* Request netCDF3 output storage format */ fl_out_fmt=NC_FORMAT_CLASSIC; break; case '4': /* Catch-all to prescribe output storage format */ if(!strcmp(opt_crr,"64bit")) fl_out_fmt=NC_FORMAT_64BIT; else fl_out_fmt=NC_FORMAT_NETCDF4; break; case '6': /* Request netCDF3 64-bit offset output storage format */ fl_out_fmt=NC_FORMAT_64BIT; break; case '7': /* Request netCDF4-classic output storage format */ fl_out_fmt=NC_FORMAT_NETCDF4_CLASSIC; break; case 'A': /* Toggle FORCE_APPEND */ FORCE_APPEND=!FORCE_APPEND; break; case 'C': /* Extract all coordinates associated with extracted variables? */ EXTRACT_ASSOCIATED_COORDINATES=False; break; case 'c': EXTRACT_ALL_COORDINATES=True; break; case 'D': /* The debugging level. Default is 0. */ nco_dbg_lvl=(unsigned short int)strtoul(optarg,&sng_cnv_rcd,NCO_SNG_CNV_BASE10); if(*sng_cnv_rcd) nco_sng_cnv_err(optarg,"strtoul",sng_cnv_rcd); nc_set_log_level(nco_dbg_lvl); break; case 'd': /* Copy limit argument for later processing */ lmt_arg[lmt_nbr]=(char *)strdup(optarg); lmt_nbr++; break; case 'F': /* Toggle index convention. Default is 0-based arrays (C-style). */ FORTRAN_IDX_CNV=!FORTRAN_IDX_CNV; break; case 'G': /* Apply Group Path Editing (GPE) to output group */ /* NB: GNU getopt() optional argument syntax is ugly (requires "=" sign) so avoid it http://stackoverflow.com/questions/1052746/getopt-does-not-parse-optional-arguments-to-parameters */ gpe=nco_gpe_prs_arg(optarg); fl_out_fmt=NC_FORMAT_NETCDF4; break; case 'g': /* Copy group argument for later processing */ /* Replace commas with hashes when within braces (convert back later) */ optarg_lcl=(char *)strdup(optarg); (void)nco_rx_comma2hash(optarg_lcl); grp_lst_in=nco_lst_prs_2D(optarg_lcl,",",&grp_lst_in_nbr); optarg_lcl=(char *)nco_free(optarg_lcl); break; case 'h': /* Toggle appending to history global attribute */ HISTORY_APPEND=!HISTORY_APPEND; break; case 'i': /* Name of variable to guide interpolation. Default is none */ ntp_lst_in=nco_lst_prs_2D(optarg,",",&nbr_ntp); if(nbr_ntp > 2){ (void)fprintf(stdout,"%s: ERROR too many arguments to -i\n",nco_prg_nm_get()); nco_exit(EXIT_FAILURE); } /* end if */ ntp_nm=ntp_lst_in[0]; ntp_val_out=strtod(ntp_lst_in[1],&sng_cnv_rcd); if(*sng_cnv_rcd) nco_sng_cnv_err(ntp_lst_in[1],"strtod",sng_cnv_rcd); CMD_LN_NTP_VAR=True; CMD_LN_NTP_WGT=False; break; case 'L': /* [enm] Deflate level. Default is 0. */ dfl_lvl=(int)strtol(optarg,&sng_cnv_rcd,NCO_SNG_CNV_BASE10); if(*sng_cnv_rcd) nco_sng_cnv_err(optarg,"strtol",sng_cnv_rcd); break; case 'l': /* Local path prefix for files retrieved from remote file system */ fl_pth_lcl=(char *)strdup(optarg); break; case 'O': /* Toggle FORCE_OVERWRITE */ FORCE_OVERWRITE=!FORCE_OVERWRITE; break; case 'o': /* Name of output file */ fl_out=(char *)strdup(optarg); break; case 'p': /* Common file path */ fl_pth=(char *)strdup(optarg); break; case 'R': /* Toggle removal of remotely-retrieved-files. Default is True. */ RM_RMT_FL_PST_PRC=!RM_RMT_FL_PST_PRC; break; case 'r': /* Print CVS program information and copyright notice */ (void)nco_vrs_prn(CVS_Id,CVS_Revision); (void)nco_lbr_vrs_prn(); (void)nco_cpy_prn(); (void)nco_cnf_prn(); nco_exit(EXIT_SUCCESS); break; case 't': /* Thread number */ thr_nbr=(int)strtol(optarg,&sng_cnv_rcd,NCO_SNG_CNV_BASE10); if(*sng_cnv_rcd) nco_sng_cnv_err(optarg,"strtol",sng_cnv_rcd); break; case 'v': /* Variables to extract/exclude */ /* Replace commas with hashes when within braces (convert back later) */ optarg_lcl=(char *)strdup(optarg); (void)nco_rx_comma2hash(optarg_lcl); var_lst_in=nco_lst_prs_2D(optarg_lcl,",",&var_lst_in_nbr); optarg_lcl=(char *)nco_free(optarg_lcl); xtr_nbr=var_lst_in_nbr; break; case 'w': /* Weight(s) for interpolation. Default is wgt_val_1=wgt_val_2=0.5 */ ntp_lst_in=nco_lst_prs_2D(optarg,",",&nbr_ntp); if(nbr_ntp > 2){ (void)fprintf(stdout,"%s: ERROR too many arguments to -w\n",nco_prg_nm_get()); nco_exit(EXIT_FAILURE); }else if(nbr_ntp == 2){ wgt_val_1=strtod(ntp_lst_in[0],&sng_cnv_rcd); if(*sng_cnv_rcd) nco_sng_cnv_err(ntp_lst_in[0],"strtod",sng_cnv_rcd); wgt_val_2=strtod(ntp_lst_in[1],&sng_cnv_rcd); if(*sng_cnv_rcd) nco_sng_cnv_err(ntp_lst_in[1],"strtod",sng_cnv_rcd); }else if(nbr_ntp == 1){ wgt_val_1=strtod(ntp_lst_in[0],&sng_cnv_rcd); if(*sng_cnv_rcd) nco_sng_cnv_err(ntp_lst_in[0],"strtod",sng_cnv_rcd); wgt_val_2=1.0-wgt_val_1; } /* end else */ CMD_LN_NTP_WGT=True; break; case 'X': /* Copy auxiliary coordinate argument for later processing */ aux_arg[aux_nbr]=(char *)strdup(optarg); aux_nbr++; MSA_USR_RDR=True; /* [flg] Multi-Slab Algorithm returns hyperslabs in user-specified order */ break; case 'x': /* Exclude rather than extract variables specified with -v */ EXCLUDE_INPUT_LIST=True; break; case '?': /* Print proper usage */ (void)nco_usg_prn(); nco_exit(EXIT_SUCCESS); break; case '-': /* Long options are not allowed */ (void)fprintf(stderr,"%s: ERROR Long options are not available in this build. Use single letter options instead.\n",nco_prg_nm_get()); nco_exit(EXIT_FAILURE); break; default: /* Print proper usage */ (void)fprintf(stdout,"%s ERROR in command-line syntax/options. Please reformulate command accordingly.\n",nco_prg_nm_get()); (void)nco_usg_prn(); nco_exit(EXIT_FAILURE); break; } /* end switch */ if(opt_crr) opt_crr=(char *)nco_free(opt_crr); } /* end while loop */ if(CMD_LN_NTP_VAR && CMD_LN_NTP_WGT){ (void)fprintf(stdout,"%s: ERROR interpolating variable (-i) and fixed weight(s) (-w) both set\n",nco_prg_nm_get()); nco_exit(EXIT_FAILURE); }else if(!CMD_LN_NTP_VAR && !CMD_LN_NTP_WGT){ (void)fprintf(stdout,"%s: ERROR interpolating variable (-i) or fixed weight(s) (-w) must be set\n",nco_prg_nm_get()); nco_exit(EXIT_FAILURE); } /* end else */ /* Process positional arguments and fill in filenames */ fl_lst_in=nco_fl_lst_mk(argv,argc,optind,&fl_nbr,&fl_out,&FL_LST_IN_FROM_STDIN); /* Initialize thread information */ thr_nbr=nco_openmp_ini(thr_nbr); in_id_1_arr=(int *)nco_malloc(thr_nbr*sizeof(int)); in_id_2_arr=(int *)nco_malloc(thr_nbr*sizeof(int)); /* Parse filenames */ fl_idx=0; /* Input file _1 */ fl_in_1=nco_fl_nm_prs(fl_in_1,fl_idx,&fl_nbr,fl_lst_in,abb_arg_nbr,fl_lst_abb,fl_pth); if(nco_dbg_lvl >= nco_dbg_fl) (void)fprintf(stderr,"%s: INFO Input file %d is %s",nco_prg_nm_get(),fl_idx,fl_in_1); /* Make sure file is on local system and is readable or die trying */ fl_in_1=nco_fl_mk_lcl(fl_in_1,fl_pth_lcl,&FILE_1_RETRIEVED_FROM_REMOTE_LOCATION); if(nco_dbg_lvl >= nco_dbg_fl && FILE_1_RETRIEVED_FROM_REMOTE_LOCATION) (void)fprintf(stderr,", local file is %s",fl_in_1); if(nco_dbg_lvl >= nco_dbg_fl) (void)fprintf(stderr,"\n"); /* Open file once per thread to improve caching */ if(RAM_OPEN) md_open=NC_NOWRITE|NC_DISKLESS; else md_open=NC_NOWRITE; for(thr_idx=0;thr_idx<thr_nbr;thr_idx++) rcd+=nco_fl_open(fl_in_1,md_open,&bfr_sz_hnt,in_id_1_arr+thr_idx); in_id_1=in_id_1_arr[0]; fl_idx=1; /* Input file _2 */ fl_in_2=nco_fl_nm_prs(fl_in_2,fl_idx,&fl_nbr,fl_lst_in,abb_arg_nbr,fl_lst_abb,fl_pth); if(nco_dbg_lvl >= nco_dbg_fl) (void)fprintf(stderr,"%s: INFO Input file %d is %s",nco_prg_nm_get(),fl_idx,fl_in_2); /* Make sure file is on local system and is readable or die trying */ fl_in_2=nco_fl_mk_lcl(fl_in_2,fl_pth_lcl,&FILE_2_RETRIEVED_FROM_REMOTE_LOCATION); if(nco_dbg_lvl >= nco_dbg_fl && FILE_2_RETRIEVED_FROM_REMOTE_LOCATION) (void)fprintf(stderr,", local file is %s",fl_in_2); if(nco_dbg_lvl >= nco_dbg_fl) (void)fprintf(stderr,"\n"); /* Open file once per thread to improve caching */ if(RAM_OPEN) md_open=NC_NOWRITE|NC_DISKLESS; else md_open=NC_NOWRITE; for(thr_idx=0;thr_idx<thr_nbr;thr_idx++) rcd+=nco_fl_open(fl_in_2,md_open,&bfr_sz_hnt,in_id_2_arr+thr_idx); in_id_2=in_id_2_arr[0]; (void)nco_inq_format(in_id_1,&fl_in_fmt_1); (void)nco_inq_format(in_id_2,&fl_in_fmt_2); trv_tbl_init(&trv_tbl); /* Construct GTT, Group Traversal Table (groups,variables,dimensions, limits) */ (void)nco_bld_trv_tbl(in_id_1,trv_pth,lmt_nbr,lmt_arg,aux_nbr,aux_arg,MSA_USR_RDR,FORTRAN_IDX_CNV,grp_lst_in,grp_lst_in_nbr,var_lst_in,xtr_nbr,EXTRACT_ALL_COORDINATES,GRP_VAR_UNN,False,EXCLUDE_INPUT_LIST,EXTRACT_ASSOCIATED_COORDINATES,nco_pck_plc_nil,&flg_dne,trv_tbl); /* Were all user-specified dimensions found? */ (void)nco_chk_dmn(lmt_nbr,flg_dne); /* Get number of variables, dimensions, and global attributes in file, file format */ (void)trv_tbl_inq((int *)NULL,(int *)NULL,(int *)NULL,&nbr_dmn_fl,(int *)NULL,(int *)NULL,(int *)NULL,(int *)NULL,&nbr_var_fl,trv_tbl); /* Fill-in variable structure list for all extracted variables */ var=nco_fll_var_trv(in_id_1,&xtr_nbr,trv_tbl); var_out=(var_sct **)nco_malloc(xtr_nbr*sizeof(var_sct *)); for(int var_idx=0;var_idx<xtr_nbr;var_idx++) var_out[var_idx]=nco_var_dpl(var[var_idx]); /* Is this a CCM/CCSM/CF-format history tape? */ CNV_CCM_CCSM_CF=nco_cnv_ccm_ccsm_cf_inq(in_id_1); /* Divide variable lists into lists of fixed variables and variables to be processed */ (void)nco_var_lst_dvd(var,var_out,xtr_nbr,CNV_CCM_CCSM_CF,FIX_REC_CRD,nco_pck_plc_nil,nco_pck_map_nil,(dmn_sct **)NULL,0,&var_fix,&var_fix_out,&nbr_var_fix,&var_prc_1,&var_prc_out,&nbr_var_prc,trv_tbl); /* Store processed and fixed variables info into GTT */ (void)nco_var_prc_fix_trv(nbr_var_prc,var_prc_1,nbr_var_fix,var_fix,trv_tbl); /* Make output and input files consanguinous */ if(fl_out_fmt == NCO_FORMAT_UNDEFINED) fl_out_fmt=fl_in_fmt_1; /* Initialize, decode, and set PPC information */ if(ppc_nbr > 0) nco_ppc_ini(in_id_1,&dfl_lvl,fl_out_fmt,ppc_arg,ppc_nbr,trv_tbl); /* Verify output file format supports requested actions */ (void)nco_fl_fmt_vet(fl_out_fmt,cnk_nbr,dfl_lvl); /* Open output file */ fl_out_tmp=nco_fl_out_open(fl_out,FORCE_APPEND,FORCE_OVERWRITE,fl_out_fmt,&bfr_sz_hnt,RAM_CREATE,RAM_OPEN,WRT_TMP_FL,&out_id); /* Initialize chunking from user-specified inputs */ if(fl_out_fmt == NC_FORMAT_NETCDF4 || fl_out_fmt == NC_FORMAT_NETCDF4_CLASSIC) rcd+=nco_cnk_ini(in_id_1,fl_out,cnk_arg,cnk_nbr,cnk_map,cnk_plc,cnk_min_byt,cnk_sz_byt,cnk_sz_scl,&cnk); /* Transfer variable type to table. NOTE: Using var/xtr_nbr containing all variables (processed, fixed) */ (void)nco_var_typ_trv(xtr_nbr,var,trv_tbl); /* Define dimensions, extracted groups, variables, and attributes in output file */ (void)nco_xtr_dfn(in_id_1,out_id,&cnk,dfl_lvl,gpe,md5,!FORCE_APPEND,True,False,nco_pck_plc_nil,(char *)NULL,trv_tbl); /* Catenate time-stamped command line to "history" global attribute */ if(HISTORY_APPEND) (void)nco_hst_att_cat(out_id,cmd_ln); if(HISTORY_APPEND && FORCE_APPEND) (void)nco_prv_att_cat(fl_in_1,in_id_1,out_id); if(HISTORY_APPEND) (void)nco_vrs_att_cat(out_id); if(thr_nbr > 0 && HISTORY_APPEND) (void)nco_thr_att_cat(out_id,thr_nbr); /* Turn off default filling behavior to enhance efficiency */ nco_set_fill(out_id,NC_NOFILL,&fll_md_old); /* Take output file out of define mode */ if(hdr_pad == 0UL){ (void)nco_enddef(out_id); }else{ (void)nco__enddef(out_id,hdr_pad); if(nco_dbg_lvl >= nco_dbg_scl) (void)fprintf(stderr,"%s: INFO Padding header with %lu extra bytes\n",nco_prg_nm_get(),(unsigned long)hdr_pad); } /* hdr_pad */ /* Assign zero to start and unity to stride vectors in output variables */ (void)nco_var_srd_srt_set(var_out,xtr_nbr); /* Copy variable data for non-processed variables */ (void)nco_cpy_fix_var_trv(in_id_1,out_id,gpe,trv_tbl); /* Perform various error-checks on input file */ if(False) (void)nco_fl_cmp_err_chk(); /* ncflint-specific stuff: */ /* Find the weighting variable in input file */ if(CMD_LN_NTP_VAR){ var_sct *ntp_1=NULL; var_sct *ntp_2=NULL; var_sct *ntp_var_out; /* Turn arrival point into pseudo-variable */ val_gnr_unn.d=ntp_val_out; /* Generic container for arrival point or weight */ ntp_var_out=scl_mk_var(val_gnr_unn,NC_DOUBLE); int xtr_nbr_ntp_1; int xtr_nbr_ntp_2; var_sct ** var_ntp_1; var_sct ** var_ntp_2; /* Fill-in variable structure list for all variables named "ntp_nm" NOTE: using table from file 1 */ var_ntp_1=nco_var_trv(in_id_1,ntp_nm,&xtr_nbr_ntp_1,trv_tbl); var_ntp_2=nco_var_trv(in_id_2,ntp_nm,&xtr_nbr_ntp_2,trv_tbl); if (xtr_nbr_ntp_1) ntp_1=var_ntp_1[0]; if (xtr_nbr_ntp_2) ntp_2=var_ntp_2[0]; if(!xtr_nbr_ntp_1 || !xtr_nbr_ntp_2){ (void)fprintf(fp_stdout,"%s: ERROR Variable %s is not present in input file. ncflint assumes same file structure for both input files\n",nco_prg_nm_get(),ntp_nm); nco_exit(EXIT_FAILURE); } /* endif */ /* Read */ (void)nco_msa_var_get_trv(in_id_1,ntp_1,trv_tbl); (void)nco_msa_var_get_trv(in_id_2,ntp_2,trv_tbl); /* Currently, only support scalar variables */ if(ntp_1->sz > 1 || ntp_2->sz > 1){ (void)fprintf(stdout,"%s: ERROR interpolation variable %s must be scalar\n",nco_prg_nm_get(),ntp_nm); nco_exit(EXIT_FAILURE); } /* end if */ /* Weights must be NC_DOUBLE */ ntp_1=nco_var_cnf_typ((nc_type)NC_DOUBLE,ntp_1); ntp_2=nco_var_cnf_typ((nc_type)NC_DOUBLE,ntp_2); /* Check for degenerate case */ if(ntp_1->val.dp[0] == ntp_2->val.dp[0]){ (void)fprintf(stdout,"%s: ERROR Interpolation variable %s is identical (%g) in input files, therefore unable to interpolate.\n",nco_prg_nm_get(),ntp_nm,ntp_1->val.dp[0]); nco_exit(EXIT_FAILURE); } /* end if */ /* Turn weights into pseudo-variables */ wgt_1=nco_var_dpl(ntp_2); wgt_2=nco_var_dpl(ntp_var_out); /* Subtract to find interpolation distances */ (void)nco_var_sbt(ntp_1->type,ntp_1->sz,ntp_1->has_mss_val,ntp_1->mss_val,ntp_var_out->val,wgt_1->val); (void)nco_var_sbt(ntp_1->type,ntp_1->sz,ntp_1->has_mss_val,ntp_1->mss_val,ntp_1->val,wgt_2->val); (void)nco_var_sbt(ntp_1->type,ntp_1->sz,ntp_1->has_mss_val,ntp_1->mss_val,ntp_1->val,ntp_2->val); /* Normalize to obtain final interpolation weights */ (void)nco_var_dvd(wgt_1->type,wgt_1->sz,wgt_1->has_mss_val,wgt_1->mss_val,ntp_2->val,wgt_1->val); (void)nco_var_dvd(wgt_2->type,wgt_2->sz,wgt_2->has_mss_val,wgt_2->mss_val,ntp_2->val,wgt_2->val); for(idx=0;idx<xtr_nbr_ntp_1;idx++) var_ntp_1[idx]=nco_var_free(var_ntp_1[idx]); for(idx=0;idx<xtr_nbr_ntp_2;idx++) var_ntp_2[idx]=nco_var_free(var_ntp_2[idx]); var_ntp_1=(var_sct **)nco_free(var_ntp_1); var_ntp_2=(var_sct **)nco_free(var_ntp_2); if(ntp_var_out) ntp_var_out=nco_var_free(ntp_var_out); } /* end if CMD_LN_NTP_VAR */ if(CMD_LN_NTP_WGT){ val_gnr_unn.d=wgt_val_1; /* Generic container for arrival point or weight */ wgt_1=scl_mk_var(val_gnr_unn,NC_DOUBLE); val_gnr_unn.d=wgt_val_2; /* Generic container for arrival point or weight */ wgt_2=scl_mk_var(val_gnr_unn,NC_DOUBLE); } /* end if CMD_LN_NTP_WGT */ if(nco_dbg_lvl >= nco_dbg_scl) (void)fprintf(stderr,"wgt_1 = %g, wgt_2 = %g\n",wgt_1->val.dp[0],wgt_2->val.dp[0]); /* Create structure list for second file */ var_prc_2=(var_sct **)nco_malloc(nbr_var_prc*sizeof(var_sct *)); /* Timestamp end of metadata setup and disk layout */ rcd+=nco_ddra((char *)NULL,(char *)NULL,&ddra_info); ddra_info.tmr_flg=nco_tmr_rgl; /* Loop over each interpolated variable */ #ifdef _OPENMP /* OpenMP notes: shared(): msk and wgt are not altered within loop private(): wgt_avg does not need initialization */ # pragma omp parallel for default(none) firstprivate(wgt_1,wgt_2,wgt_out_1,wgt_out_2) private(DO_CONFORM,idx,in_id_1,in_id_2,has_mss_val) shared(MUST_CONFORM,nco_dbg_lvl,fl_in_1,fl_in_2,fl_out,gpe,in_id_1_arr,in_id_2_arr,nbr_var_prc,out_id,nco_prg_nm,var_prc_1,var_prc_2,var_prc_out,nbr_dmn_fl,trv_tbl) #endif /* !_OPENMP */ for(idx=0;idx<nbr_var_prc;idx++){ /* Note: Using object 2 from table 1, only one table built, assumes same structure for processed objects in both files */ char *grp_out_fll=NULL; /* [sng] Group name */ int grp_id_1; /* [ID] Group ID */ int grp_id_2; /* [ID] Group ID */ int grp_out_id; /* [ID] Group ID (output) */ int var_out_id; /* [ID] Variable ID (output) */ trv_sct *var_trv_1;/* [sct] Variable GTT object */ trv_sct *var_trv_2;/* [sct] Variable GTT object */ if(nco_dbg_lvl >= nco_dbg_var) (void)fprintf(fp_stderr,"%s, ",var_prc_1[idx]->nm); if(nco_dbg_lvl >= nco_dbg_var) (void)fflush(fp_stderr); in_id_1=in_id_1_arr[omp_get_thread_num()]; in_id_2=in_id_2_arr[omp_get_thread_num()]; var_prc_2[idx]=nco_var_dpl(var_prc_1[idx]); /* Obtain variable GTT object using full variable name */ var_trv_1=trv_tbl_var_nm_fll(var_prc_1[idx]->nm_fll,trv_tbl); var_trv_2=trv_tbl_var_nm_fll(var_prc_2[idx]->nm_fll,trv_tbl); if(!var_trv_2){ (void)fprintf(fp_stdout,"%s: ERROR Variable %s is not present in second input file. ncflint assumes same structure for processed objects in both files\n",nco_prg_nm_get(),var_trv_1->nm_fll); nco_exit(EXIT_FAILURE); } /* endif */ /* Obtain group ID */ (void)nco_inq_grp_full_ncid(in_id_1,var_trv_1->grp_nm_fll,&grp_id_1); (void)nco_inq_grp_full_ncid(in_id_2,var_trv_2->grp_nm_fll,&grp_id_2); (void)nco_var_mtd_refresh(grp_id_2,var_prc_2[idx]); /* Read */ (void)nco_msa_var_get_trv(in_id_1,var_prc_1[idx],trv_tbl); (void)nco_msa_var_get_trv(in_id_2,var_prc_2[idx],trv_tbl); /* Set var_prc_1 and var_prc_2 to correct size */ var_prc_1[idx]->sz=var_prc_out[idx]->sz; var_prc_2[idx]->sz=var_prc_out[idx]->sz; /* Stretch second variable to match dimensions of first variable */ wgt_out_1=nco_var_cnf_dmn(var_prc_out[idx],wgt_1,wgt_out_1,MUST_CONFORM,&DO_CONFORM); wgt_out_2=nco_var_cnf_dmn(var_prc_out[idx],wgt_2,wgt_out_2,MUST_CONFORM,&DO_CONFORM); var_prc_1[idx]=nco_var_cnf_typ((nc_type)NC_DOUBLE,var_prc_1[idx]); var_prc_2[idx]=nco_var_cnf_typ((nc_type)NC_DOUBLE,var_prc_2[idx]); /* Allocate and, if necesssary, initialize space for processed variable */ var_prc_out[idx]->sz=var_prc_1[idx]->sz; /* NB: must not try to free() same tally buffer twice */ /* var_prc_out[idx]->tally=var_prc_1[idx]->tally=(long *)nco_malloc(var_prc_out[idx]->sz*sizeof(long int));*/ var_prc_out[idx]->tally=(long *)nco_malloc(var_prc_out[idx]->sz*sizeof(long int)); (void)nco_zero_long(var_prc_out[idx]->sz,var_prc_out[idx]->tally); /* Weight variable by taking product of weight with variable */ (void)nco_var_mlt(var_prc_1[idx]->type,var_prc_1[idx]->sz,var_prc_1[idx]->has_mss_val,var_prc_1[idx]->mss_val,wgt_out_1->val,var_prc_1[idx]->val); (void)nco_var_mlt(var_prc_2[idx]->type,var_prc_2[idx]->sz,var_prc_2[idx]->has_mss_val,var_prc_2[idx]->mss_val,wgt_out_2->val,var_prc_2[idx]->val); /* Change missing_value of var_prc_2, if any, to missing_value of var_prc_1, if any */ has_mss_val=nco_mss_val_cnf(var_prc_1[idx],var_prc_2[idx]); /* NB: fxm: use tally to determine when to "unweight" answer? TODO */ (void)nco_var_add_tll_ncflint(var_prc_1[idx]->type,var_prc_1[idx]->sz,has_mss_val,var_prc_1[idx]->mss_val,var_prc_out[idx]->tally,var_prc_1[idx]->val,var_prc_2[idx]->val); /* Re-cast output variable to original type */ var_prc_2[idx]=nco_var_cnf_typ(var_prc_out[idx]->type,var_prc_2[idx]); /* Edit group name for output */ if(gpe) grp_out_fll=nco_gpe_evl(gpe,var_trv_1->grp_nm_fll); else grp_out_fll=(char *)strdup(var_trv_1->grp_nm_fll); /* Obtain output group ID */ (void)nco_inq_grp_full_ncid(out_id,grp_out_fll,&grp_out_id); /* Memory management after current extracted group */ if(grp_out_fll) grp_out_fll=(char *)nco_free(grp_out_fll); /* Get variable ID */ (void)nco_inq_varid(grp_out_id,var_trv_1->nm,&var_out_id); /* Store the output variable ID */ var_prc_out[idx]->id=var_out_id; if(var_trv_1->ppc != NC_MAX_INT){ if(var_trv_1->flg_nsd) (void)nco_ppc_bitmask(var_trv_1->ppc,var_prc_2[idx]->type,var_prc_out[idx]->sz,var_prc_out[idx]->has_mss_val,var_prc_out[idx]->mss_val,var_prc_2[idx]->val); else (void)nco_ppc_around(var_trv_1->ppc,var_prc_2[idx]->type,var_prc_out[idx]->sz,var_prc_out[idx]->has_mss_val,var_prc_out[idx]->mss_val,var_prc_2[idx]->val); } /* endif ppc */ if(nco_is_xcp(var_trv_1->nm)) nco_xcp_prc(var_trv_1->nm,var_prc_2[idx]->type,var_prc_out[idx]->sz,(char *)var_prc_2[idx]->val.vp); #ifdef _OPENMP # pragma omp critical #endif /* _OPENMP */ { /* begin OpenMP critical */ /* Copy interpolations to output file */ if(!var_prc_out[idx]->nbr_dim) (void)nco_put_var1(grp_out_id,var_prc_out[idx]->id,var_prc_out[idx]->srt,var_prc_2[idx]->val.vp,var_prc_2[idx]->type); else (void)nco_put_vara(grp_out_id,var_prc_out[idx]->id,var_prc_out[idx]->srt,var_prc_out[idx]->cnt,var_prc_2[idx]->val.vp,var_prc_2[idx]->type); } /* end OpenMP critical */ /* Free dynamically allocated buffers */ if(var_prc_1[idx]) var_prc_1[idx]=nco_var_free(var_prc_1[idx]); if(var_prc_2[idx]) var_prc_2[idx]=nco_var_free(var_prc_2[idx]); if(var_prc_out[idx]) var_prc_out[idx]=nco_var_free(var_prc_out[idx]); } /* end (OpenMP parallel for) loop over idx */ if(nco_dbg_lvl >= nco_dbg_var) (void)fprintf(stderr,"\n"); /* Close input netCDF files */ for(thr_idx=0;thr_idx<thr_nbr;thr_idx++) nco_close(in_id_1_arr[thr_idx]); for(thr_idx=0;thr_idx<thr_nbr;thr_idx++) nco_close(in_id_2_arr[thr_idx]); /* Close output file and move it from temporary to permanent location */ (void)nco_fl_out_cls(fl_out,fl_out_tmp,out_id); /* Remove local copy of file */ if(FILE_1_RETRIEVED_FROM_REMOTE_LOCATION && RM_RMT_FL_PST_PRC) (void)nco_fl_rm(fl_in_1); if(FILE_2_RETRIEVED_FROM_REMOTE_LOCATION && RM_RMT_FL_PST_PRC) (void)nco_fl_rm(fl_in_2); /* Clean memory unless dirty memory allowed */ if(flg_cln){ /* ncflint-specific memory */ if(fl_in_1) fl_in_1=(char *)nco_free(fl_in_1); if(fl_in_2) fl_in_2=(char *)nco_free(fl_in_2); var_prc_1=(var_sct **)nco_free(var_prc_1); var_prc_2=(var_sct **)nco_free(var_prc_2); if(wgt_1) wgt_1=(var_sct *)nco_var_free(wgt_1); if(wgt_2) wgt_2=(var_sct *)nco_var_free(wgt_2); if(wgt_out_1) wgt_out_1=(var_sct *)nco_var_free(wgt_out_1); if(wgt_out_2) wgt_out_2=(var_sct *)nco_var_free(wgt_out_2); /* NCO-generic clean-up */ /* Free individual strings/arrays */ if(cmd_ln) cmd_ln=(char *)nco_free(cmd_ln); if(cnk_map_sng) cnk_map_sng=(char *)nco_free(cnk_map_sng); if(cnk_plc_sng) cnk_plc_sng=(char *)nco_free(cnk_plc_sng); if(fl_out) fl_out=(char *)nco_free(fl_out); if(fl_out_tmp) fl_out_tmp=(char *)nco_free(fl_out_tmp); if(fl_pth) fl_pth=(char *)nco_free(fl_pth); if(fl_pth_lcl) fl_pth_lcl=(char *)nco_free(fl_pth_lcl); if(in_id_1_arr) in_id_1_arr=(int *)nco_free(in_id_1_arr); if(in_id_2_arr) in_id_2_arr=(int *)nco_free(in_id_2_arr); /* Free lists of strings */ if(fl_lst_in && fl_lst_abb == NULL) fl_lst_in=nco_sng_lst_free(fl_lst_in,fl_nbr); if(fl_lst_in && fl_lst_abb) fl_lst_in=nco_sng_lst_free(fl_lst_in,1); if(fl_lst_abb) fl_lst_abb=nco_sng_lst_free(fl_lst_abb,abb_arg_nbr); if(var_lst_in_nbr > 0) var_lst_in=nco_sng_lst_free(var_lst_in,var_lst_in_nbr); /* Free limits */ for(idx=0;idx<aux_nbr;idx++) aux_arg[idx]=(char *)nco_free(aux_arg[idx]); for(idx=0;idx<lmt_nbr;idx++) lmt_arg[idx]=(char *)nco_free(lmt_arg[idx]); for(idx=0;idx<ppc_nbr;idx++) ppc_arg[idx]=(char *)nco_free(ppc_arg[idx]); /* Free chunking information */ for(idx=0;idx<cnk_nbr;idx++) cnk_arg[idx]=(char *)nco_free(cnk_arg[idx]); if(cnk_nbr > 0) cnk.cnk_dmn=(cnk_dmn_sct **)nco_cnk_lst_free(cnk.cnk_dmn,cnk_nbr); var=(var_sct **)nco_free(var); var_out=(var_sct **)nco_free(var_out); var_prc_out=(var_sct **)nco_free(var_prc_out); if(nbr_var_fix > 0) var_fix=nco_var_lst_free(var_fix,nbr_var_fix); if(nbr_var_fix > 0) var_fix_out=nco_var_lst_free(var_fix_out,nbr_var_fix); trv_tbl_free(trv_tbl); for(idx=0;idx<lmt_nbr;idx++) flg_dne[idx].dim_nm=(char *)nco_free(flg_dne[idx].dim_nm); if(flg_dne) flg_dne=(nco_dmn_dne_t *)nco_free(flg_dne); if(gpe) gpe=(gpe_sct *)nco_gpe_free(gpe); } /* !flg_cln */ #ifdef ENABLE_MPI MPI_Finalize(); #endif /* !ENABLE_MPI */ /* End timer */ ddra_info.tmr_flg=nco_tmr_end; /* [enm] Timer flag */ rcd+=nco_ddra((char *)NULL,(char *)NULL,&ddra_info); if(rcd != NC_NOERR) nco_err_exit(rcd,"main"); nco_exit_gracefully(); return EXIT_SUCCESS; } /* end main() */
int iceb_l_opmup_v(class iceb_u_str *kod_op,GtkWidget *wpredok) { class iceb_l_opmup_v_data data; char strsql[512]; SQL_str row; SQLCURSOR cur; data.kod_op.new_plus(kod_op->ravno()); data.rk.clear_zero(); if(data.kod_op.getdlinna() > 1) { data.rk.kod.new_plus(data.kod_op.ravno()); sprintf(strsql,"select * from Prihod where kod='%s'",data.kod_op.ravno()); if(iceb_sql_readkey(strsql,&row,&cur,wpredok) != 1) { iceb_menu_soob(gettext("Не найдена запись для корректировки !"),wpredok); return(1); } data.rk.naim.new_plus(row[1]); data.rk.vidop=atoi(row[4]); data.rk.prov=atoi(row[5]); } data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); if(data.kod_op.getdlinna() <= 1) sprintf(strsql,"%s %s",name_system,gettext("Ввод новой записи")); else sprintf(strsql,"%s %s",name_system,gettext("Корректировка записи")); gtk_window_set_title(GTK_WINDOW(data.window),strsql); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(opmup_v_key_press),&data); if(wpredok != NULL) { gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok)); //Закрыть окно если окно предок удалено gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE); } if(data.kod_op.getdlinna() <= 1) sprintf(strsql,"%s",gettext("Ввод новой записи")); else { sprintf(strsql,"%s\n%s:%s %s:%s", gettext("Корректировка записи"), gettext("Записал"), iceb_kszap(row[2],1,wpredok), gettext("Дата и время записи"), iceb_u_vremzap(row[3])); } GtkWidget *label=gtk_label_new(iceb_u_toutf(strsql)); GtkWidget *vbox = gtk_vbox_new (FALSE, 0); GtkWidget *hbox1 = gtk_hbox_new (FALSE, 0); GtkWidget *hbox2 = gtk_hbox_new (FALSE, 0); GtkWidget *hbox3 = gtk_hbox_new (FALSE, 0); GtkWidget *hbox4 = gtk_hbox_new (FALSE, 0); GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (data.window), vbox); gtk_container_add (GTK_CONTAINER (vbox), label); gtk_container_add (GTK_CONTAINER (vbox), hbox1); gtk_container_add (GTK_CONTAINER (vbox), hbox2); gtk_container_add (GTK_CONTAINER (vbox), hbox3); gtk_container_add (GTK_CONTAINER (vbox), hbox4); gtk_container_add (GTK_CONTAINER (vbox), hboxknop); label=gtk_label_new(gettext("Код")); gtk_box_pack_start (GTK_BOX (hbox1), label, FALSE, FALSE, 0); data.entry[E_KOD] = gtk_entry_new_with_max_length (10); gtk_box_pack_start (GTK_BOX (hbox1), data.entry[E_KOD], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD]), "activate",GTK_SIGNAL_FUNC(opmup_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD]),data.rk.kod.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD]),(gpointer)E_KOD); label=gtk_label_new(gettext("Наименование")); gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0); data.entry[E_NAIM] = gtk_entry_new_with_max_length (80); gtk_box_pack_start (GTK_BOX (hbox2), data.entry[E_NAIM], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_NAIM]), "activate",GTK_SIGNAL_FUNC(opmup_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_NAIM]),data.rk.naim.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_NAIM]),(gpointer)E_NAIM); label=gtk_label_new(gettext("Вид операции")); gtk_box_pack_start (GTK_BOX (hbox3), label, FALSE, FALSE, 0); GtkWidget *menuvid = opmup_vidop_v(&data.rk.vidop); gtk_box_pack_start (GTK_BOX (hbox3), menuvid, FALSE, FALSE, 0); label=gtk_label_new(gettext("Проводки")); gtk_box_pack_start (GTK_BOX (hbox4), label, FALSE, FALSE, 0); menuvid = opmup_vidop_p(&data.rk.prov); gtk_box_pack_start (GTK_BOX (hbox4), menuvid, FALSE, FALSE, 0); //GtkWidget *knopka[KOL_PFK]; GtkTooltips *tooltips[KOL_PFK]; sprintf(strsql,"F2 %s",gettext("Запись")); data.knopka[PFK2]=gtk_button_new_with_label(strsql); tooltips[PFK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[PFK2],data.knopka[PFK2],gettext("Запись введеной в меню информации"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[PFK2]),"clicked",GTK_SIGNAL_FUNC(opmup_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[PFK2]),(gpointer)PFK2); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka[PFK10]=gtk_button_new_with_label(strsql); tooltips[PFK10]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[PFK10],data.knopka[PFK10],gettext("Завершение работы с меню без записи введенной информации"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[PFK10]),"clicked",GTK_SIGNAL_FUNC(opmup_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[PFK10]),(gpointer)PFK10); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[PFK2], TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[PFK10], TRUE, TRUE, 0); gtk_widget_grab_focus(data.entry[0]); gtk_widget_show_all (data.window); gtk_main(); if(data.voz == 0) kod_op->new_plus(data.rk.kod.ravno()); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); return(data.voz); }
/* Generate Outout ** =============== */ PRIVATE void WSRC_gen_html ARGS2(HTStream *, me, BOOL, source_file) { if (me->par_value[PAR_DATABASE_NAME]) { char * shortname = 0; int l; StrAllocCopy(shortname, me->par_value[PAR_DATABASE_NAME]); l = strlen(shortname); if ( l > 4 && !strcasecomp(shortname + l -4, ".src")) { shortname[l-4] = 0; /* Chop of .src -- boring! */ } START(HTML_HEAD); PUTC('\n'); START(HTML_TITLE); PUTS(shortname); PUTS(source_file ? gettext(" WAIS source file") : INDEX_SEGMENT); END(HTML_TITLE); PUTC('\n'); END(HTML_HEAD); START(HTML_H1); PUTS(shortname); PUTS(source_file ? gettext(" description") : INDEX_SEGMENT); END(HTML_H1); PUTC('\n'); FREE(shortname); } START(HTML_DL); /* Definition list of details */ if (source_file) { START(HTML_DT); PUTS(gettext("Access links")); MAYBE_END(HTML_DT); START(HTML_DD); if (me->par_value[PAR_IP_NAME] && me->par_value[PAR_DATABASE_NAME]) { char * WSRC_address = NULL; char * www_database; www_database = HTEscape(me->par_value[PAR_DATABASE_NAME], URL_XALPHAS); HTSprintf0(&WSRC_address, "%s//%s%s%s/%s", STR_WAIS_URL, me->par_value[PAR_IP_NAME], me->par_value[PAR_TCP_PORT] ? ":" : "", me->par_value[PAR_TCP_PORT] ? me->par_value[PAR_TCP_PORT] :"", www_database); HTStartAnchor(me->target, NULL, WSRC_address); PUTS(gettext("Direct access")); END(HTML_A); /** Proxy will be used if defined, so let user know that - FM **/ PUTS(gettext(" (or via proxy server, if defined)")); FREE(www_database); FREE(WSRC_address); } else { give_parameter(me, PAR_IP_NAME); give_parameter(me, PAR_DATABASE_NAME); } MAYBE_END(HTML_DD); } /* end if source_file */ if (me->par_value[PAR_MAINTAINER]) { START(HTML_DT); PUTS(gettext("Maintainer")); MAYBE_END(HTML_DT); START(HTML_DD); PUTS(me->par_value[PAR_MAINTAINER]); MAYBE_END(HTML_DD); } if (me->par_value[PAR_IP_NAME]) { START(HTML_DT); PUTS(gettext("Host")); MAYBE_END(HTML_DT); START(HTML_DD); PUTS(me->par_value[PAR_IP_NAME]); MAYBE_END(HTML_DD); } END(HTML_DL); if (me->par_value[PAR_DESCRIPTION]) { START(HTML_PRE); /* Preformatted description */ PUTS(me->par_value[PAR_DESCRIPTION]); END(HTML_PRE); } (*me->target->isa->_free)(me->target); return; } /* generate html */
/* * After we're done with getopts(), process the rest of the * operands. We have three cases and this is the priority: * * 1) [ operand... ] interval count * 2) [ operand... ] interval * 3) [ operand... ] * * The trick is that any of the operands might start with a number or even * be made up exclusively of numbers (and we have to handle negative numbers * in case a user/script gets out of line). If we find two operands at the * end of the list then we claim case 1. If we find only one operand at the * end made up only of number, then we claim case 2. Otherwise, case 3. * BTW, argc, argv don't change. */ int parse_operands( int argc, char **argv, int optind, long *interval, long *count, entity_t **entityp) /* Array of stat-able entities */ { int nentities = 0; /* Number of entities found */ int out_of_range; /* Set if 2nd-to-last operand out-of-range */ if (argc == optind) return (nentities); /* None found, returns 0 */ /* * We know exactly what the maximum number of entities is going * to be: argc - optind */ if ((*entityp = calloc((argc - optind), sizeof (entity_t))) == NULL) { perror("calloc() entities"); return (-1); } for (/* void */; argc > optind; optind++) { char *endptr; /* If we have more than two operands left to process */ if ((argc - optind) > 2) { (*entityp)[nentities++].e_name = strdup(argv[optind]); continue; } /* If we're here, then we only have one or two operands left */ errno = 0; out_of_range = 0; *interval = strtol(argv[optind], &endptr, 10); if (*endptr && !isdigit((int)*endptr)) { /* Operand was not a number */ (*entityp)[nentities++].e_name = strdup(argv[optind]); continue; } else if (errno == ERANGE || *interval <= 0 || *interval > MAXLONG) { /* Operand was a number, just out of range */ out_of_range++; } /* * The last operand we saw was a number. If it happened to * be the last operand, then it is the interval... */ if ((argc - optind) == 1) { /* ...but we need to check the range. */ if (out_of_range) { (void) fprintf(stderr, gettext( "interval must be between 1 and " "%ld (inclusive)\n"), MAXLONG); return (-1); } else { /* * The value of the interval is valid. Set * count to something really big so it goes * virtually forever. */ *count = MAXLONG; break; } } /* * At this point, we *might* have the interval, but if the * next operand isn't a number, then we don't have either * the interval nor the count. Both must be set to the * defaults. In that case, both the current and the previous * operands are stat-able entities. */ errno = 0; *count = strtol(argv[optind + 1], &endptr, 10); if (*endptr && !isdigit((int)*endptr)) { /* * Faked out! The last operand wasn't a number so * the current and previous operands should be * stat-able entities. We also need to reset interval. */ *interval = 0; (*entityp)[nentities++].e_name = strdup(argv[optind++]); (*entityp)[nentities++].e_name = strdup(argv[optind++]); } else if (out_of_range || errno == ERANGE || *count <= 0) { (void) fprintf(stderr, gettext( "Both interval and count must be between 1 " "and %ld (inclusive)\n"), MAXLONG); return (-1); } break; /* Done! */ } return (nentities); }
static GimpExportReturn export_dialog (GSList *actions, const gchar *format_name) { GtkWidget *dialog; GtkWidget *hbox; GtkWidget *image; GtkWidget *main_vbox; GtkWidget *label; GSList *list; gchar *text; GimpExportReturn retval; g_return_val_if_fail (actions != NULL, GIMP_EXPORT_CANCEL); g_return_val_if_fail (format_name != NULL, GIMP_EXPORT_CANCEL); dialog = gimp_dialog_new (_("Export File"), "gimp-export-image", NULL, 0, gimp_standard_help_func, "gimp-export-dialog", _("_Ignore"), GTK_RESPONSE_NO, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("_Export"), GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_NO, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gimp_window_set_transient (GTK_WINDOW (dialog)); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_widget_show (hbox); image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); gtk_widget_show (image); main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_box_pack_start (GTK_BOX (hbox), main_vbox, FALSE, FALSE, 0); gtk_widget_show (main_vbox); /* the headline */ text = g_strdup_printf (_("Your image should be exported before it " "can be saved as %s for the following reasons:"), format_name); label = gtk_label_new (text); g_free (text); gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_SCALE, PANGO_SCALE_LARGE, -1); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); for (list = actions; list; list = g_slist_next (list)) { ExportAction *action = list->data; GtkWidget *frame; GtkWidget *vbox; text = g_strdup_printf (gettext (action->reason), format_name); frame = gimp_frame_new (text); g_free (text); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); if (action->possibilities[0] && action->possibilities[1]) { GtkWidget *button; GSList *radio_group = NULL; button = gtk_radio_button_new_with_label (radio_group, gettext (action->possibilities[0])); gtk_label_set_justify (GTK_LABEL (gtk_bin_get_child (GTK_BIN (button))), GTK_JUSTIFY_LEFT); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); g_signal_connect (button, "toggled", G_CALLBACK (export_toggle_callback), &action->choice); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), (action->choice == 0)); gtk_widget_show (button); button = gtk_radio_button_new_with_label (radio_group, gettext (action->possibilities[1])); gtk_label_set_justify (GTK_LABEL (gtk_bin_get_child (GTK_BIN (button))), GTK_JUSTIFY_LEFT); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), (action->choice == 1)); gtk_widget_show (button); } else if (action->possibilities[0]) { label = gtk_label_new (gettext (action->possibilities[0])); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); action->choice = 0; } gtk_widget_show (vbox); } /* the footline */ label = gtk_label_new (_("The export conversion won't modify your " "original image.")); gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC, -1); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); gtk_widget_show (dialog); switch (gimp_dialog_run (GIMP_DIALOG (dialog))) { case GTK_RESPONSE_OK: retval = GIMP_EXPORT_EXPORT; break; case GTK_RESPONSE_NO: retval = GIMP_EXPORT_IGNORE; break; default: retval = GIMP_EXPORT_CANCEL; break; } gtk_widget_destroy (dialog); return retval; }
/* * We have an array of entities that are potentially stat-able. Using * the name (e_name) of the entity, attempt to construct a ksname suitable * for use by kstat_lookup(3kstat) and fill it into the e_ksname member. * * We check the e_name against the list of file system types. If there is * no match then test to see if the path is valid. If the path is valid, * then determine the mountpoint. */ void set_ksnames(entity_t *entities, int nentities, char **fstypes, int nfstypes) { int i, j; struct statvfs64 statvfsbuf; for (i = 0; i < nentities; i++) { entity_t *ep = &entities[i]; /* Check the name against the list of fstypes */ for (j = 1; j < nfstypes; j++) { if (fstypes[j] && ep->e_name && strcmp(ep->e_name, fstypes[j]) == 0) { /* It's a file system type */ ep->e_type = ENTYPE_FSTYPE; (void) snprintf(ep->e_ksname, KSTAT_STRLEN, "%s%s", VOPSTATS_STR, ep->e_name); /* Now allocate the vopstats array */ ep->e_vs = calloc(VS_SIZE, sizeof (vopstats_t)); if (entities[i].e_vs == NULL) { perror("calloc() fstype vopstats"); exit(1); } break; } } if (j < nfstypes) /* Found it! */ continue; /* * If the entity in the exception list of fstypes, then * null out the entry so it isn't displayed and move along. */ if (is_exception(ep->e_name)) { ep->e_ksname[0] = 0; continue; } /* If we didn't find it, see if it's a path */ if (ep->e_name == NULL || statvfs64(ep->e_name, &statvfsbuf)) { /* Error - Make sure the entry is nulled out */ ep->e_ksname[0] = 0; continue; } (void) snprintf(ep->e_ksname, KSTAT_STRLEN, "%s%lx", VOPSTATS_STR, statvfsbuf.f_fsid); ep->e_fsid = statvfsbuf.f_fsid; if (set_mntpt(ep)) { (void) fprintf(stderr, gettext("Can't determine type of \"%s\"\n"), ep->e_name ? ep->e_name : gettext("<NULL>")); } else { ep->e_type = ENTYPE_MNTPT; } /* Now allocate the vopstats array */ ep->e_vs = calloc(VS_SIZE, sizeof (vopstats_t)); if (entities[i].e_vs == NULL) { perror("calloc() vopstats array"); exit(1); } } }
/* * Create a leaf vdev. Determine if this is a file or a device. If it's a * device, fill in the device id to make a complete nvlist. Valid forms for a * leaf vdev are: * * /dev/dsk/xxx Complete disk path * /xxx Full path to file * xxx Shorthand for /dev/dsk/xxx */ nvlist_t * make_leaf_vdev(const char *arg) { char path[MAXPATHLEN]; struct stat statbuf; nvlist_t *vdev = NULL; char *type = NULL; boolean_t wholedisk = B_FALSE; /* * Determine what type of vdev this is, and put the full path into * 'path'. We detect whether this is a device of file afterwards by * checking the st_mode of the file. */ if (arg[0] == '/') { /* * Complete device or file path. Exact type is determined by * examining the file descriptor afterwards. */ if (is_whole_disk(arg, &statbuf)) { wholedisk = B_TRUE; } else if (stat(arg, &statbuf) != 0) { (void) fprintf(stderr, gettext("cannot open '%s': %s\n"), arg, strerror(errno)); return (NULL); } (void) strlcpy(path, arg, sizeof (path)); } else { /* * This may be a short path for a device, or it could be total * gibberish. Check to see if it's a known device in * /dev/dsk/. As part of this check, see if we've been given a * an entire disk (minus the slice number). */ (void) snprintf(path, sizeof (path), "%s/%s", DISK_ROOT, arg); if (is_whole_disk(path, &statbuf)) { wholedisk = B_TRUE; } else if (stat(path, &statbuf) != 0) { /* * If we got ENOENT, then the user gave us * gibberish, so try to direct them with a * reasonable error message. Otherwise, * regurgitate strerror() since it's the best we * can do. */ if (errno == ENOENT) { (void) fprintf(stderr, gettext("cannot open '%s': no such " "device in %s\n"), arg, DISK_ROOT); (void) fprintf(stderr, gettext("must be a full path or " "shorthand device name\n")); return (NULL); } else { (void) fprintf(stderr, gettext("cannot open '%s': %s\n"), path, strerror(errno)); return (NULL); } } } /* * Determine whether this is a device or a file. */ if (S_ISBLK(statbuf.st_mode)) { type = VDEV_TYPE_DISK; } else if (S_ISREG(statbuf.st_mode)) { type = VDEV_TYPE_FILE; } else { (void) fprintf(stderr, gettext("cannot use '%s': must be a " "block device or regular file\n"), path); return (NULL); } /* * Finally, we have the complete device or file, and we know that it is * acceptable to use. Construct the nvlist to describe this vdev. All * vdevs have a 'path' element, and devices also have a 'devid' element. */ verify(nvlist_alloc(&vdev, NV_UNIQUE_NAME, 0) == 0); verify(nvlist_add_string(vdev, ZPOOL_CONFIG_PATH, path) == 0); verify(nvlist_add_string(vdev, ZPOOL_CONFIG_TYPE, type) == 0); if (strcmp(type, VDEV_TYPE_DISK) == 0) verify(nvlist_add_uint64(vdev, ZPOOL_CONFIG_WHOLE_DISK, (uint64_t)wholedisk) == 0); /* * For a whole disk, defer getting its devid until after labeling it. */ if (S_ISBLK(statbuf.st_mode) && !wholedisk) { /* * Get the devid for the device. */ int fd; ddi_devid_t devid; char *minor = NULL, *devid_str = NULL; if ((fd = open(path, O_RDONLY)) < 0) { (void) fprintf(stderr, gettext("cannot open '%s': " "%s\n"), path, strerror(errno)); nvlist_free(vdev); return (NULL); } if (devid_get(fd, &devid) == 0) { if (devid_get_minor_name(fd, &minor) == 0 && (devid_str = devid_str_encode(devid, minor)) != NULL) { verify(nvlist_add_string(vdev, ZPOOL_CONFIG_DEVID, devid_str) == 0); } if (devid_str != NULL) devid_str_free(devid_str); if (minor != NULL) devid_str_free(minor); devid_free(devid); } (void) close(fd); } return (vdev); }