3D Object Recognition By Corresponding and Quantizing Neural 3D Scene Representations
Abstract
We propose a system that learns to detect objects and infer their 3D poses in RGB-D images. Many existing systems can identify objects and infer 3D poses, but they heavily rely on human labels and 3D annotations. The challenge here is to achieve this without relying on strong supervision signals. To address this challenge, we propose a model that maps RGB-D images to a set of 3D visual feature maps in a differentiable fully-convolutional manner, supervised by predicting views. The 3D feature maps correspond to a featurization of the 3D world scene depicted in the images. The object 3D feature representations are invariant to camera viewpoint changes or zooms, which means feature matching can identify similar objects under different camera viewpoints. We can compare the 3D feature maps of two objects by searching alignment across scales and 3D rotations, and, as a result of the operation, we can estimate pose and scale changes without the need for 3D pose annotations. We cluster object feature maps into a set of 3D prototypes that represent familiar objects in canonical scales and orientations. We then parse images by inferring the prototype identity and 3D pose for each detected object. We compare our method to numerous baselines that do not learn 3D feature visual representations or do not attempt to correspond features across scenes, and outperform them by a large margin in the tasks of object retrieval and object pose estimation. Thanks to the 3D nature of the object-centric feature maps, the visual similarity cues are invariant to 3D pose changes or small scale changes, which gives our method an advantage over 2D and 1D methods.
Overview of 3DQ-Nets
Top: Model overview. Our model takes as input posed RGB-D images of scenes, and outputs 3D prototypes of the objects. Bottom: Evaluation tasks. (a) Scene parsing: Given a new scene, we match each detected object against the prototypes using a rotation-aware check to infer its identity and pose. (b) Image generation: We visualize prototypes with a pre-trained 3D-to-2D image renderer. (c) Few shot object labelling: Assigning a label to a prototype automatically transfers this label to its assigned instances.
Architecture"Given multi-view posed RGB-D images of scenes as input during training, our model learns to map a single RGB-D image to a completed scene 3D feature map at test time, by training for view prediction (b). The model additionally uses cross-scene and cross-object 3D correspondence mining and metric learning, to make the features more discriminative (c). Finally, using these learned features, our model quantizes object instances into a set of pose-canonical 3D prototypes using rotation-aware matching (d). These learned prototypes help improve our object detector by providing confident positive 3D object box labels (e).


{% extends "layout.html" %} {% block extra_head %} {% endblock %} {% block body %}
There is currently no active meal plan. Please choose one from below.
{% endif %}{{ m.name }}
There is currently no saved meal plans. Please go to add plan and create one now!
{% endif %}


Note
Click here to download the full example code
Compares implementations of Tranpose#
This example compares the numpy.transpose from numpy, to onnxruntime implementation. If available, tensorflow and pytorch are included as well.
Available optimisation#
The code shows which parallelisation optimisation could be used, AVX or SSE and the number of available processors. Both numpy and torch have lazy implementations, the function switches dimensions and strides but does not move any data. That’s why function contiguous was called in both cases.
import numpy
import pandas
import matplotlib.pyplot as plt
from onnxruntime import InferenceSession
from skl2onnx.common.data_types import FloatTensorType
from skl2onnx.algebra.onnx_ops import OnnxTranspose
from cpyquickhelper.numbers import measure_time
from tqdm import tqdm
from mlprodict.testing.experimental_c_impl.experimental_c import code_optimisation
print(code_optimisation())
Out:
AVX-omp=8
Transpose implementations#
Function einsum is used from tensorflow and pytorch instead of transpose. The equation reflects the required transposition.
try:
from tensorflow import transpose as tf_transpose, convert_to_tensor
except ImportError:
tf_transpose = None
try:
from torch import einsum as torch_einsum, from_numpy
except ImportError:
torch_einsum = None
def build_ort_transpose(perm, op_version=12):
node = OnnxTranspose('x', perm=perm, op_version=op_version,
output_names=['z'])
onx = node.to_onnx(inputs=[('x', FloatTensorType())],
target_opset=op_version)
sess = InferenceSession(onx.SerializeToString())
return lambda x, y: sess.run(None, {'x': x})
def loop_fct(fct, xs, ys):
for x, y in zip(xs, ys):
fct(x, y)
def perm2eq(perm):
first = "".join(chr(97 + i) for i in range(len(perm)))
second = "".join(first[p] for p in perm)
return "%s->%s" % (first, second)
def benchmark_op(perm, repeat=5, number=5, name="Transpose", shape_fct=None):
if shape_fct is None:
def shape_fct(dim): return (3, dim, 1, 512)
ort_fct = build_ort_transpose(perm)
res = []
for dim in tqdm([8, 16, 32, 64, 100, 128, 200,
256, 400, 512, 1024]):
shape = shape_fct(dim)
n_arrays = 10 if dim < 512 else 4
xs = [numpy.random.rand(*shape).astype(numpy.float32)
for _ in range(n_arrays)]
ys = [perm for _ in range(n_arrays)]
equation = perm2eq(perm)
info = dict(perm=perm, shape=shape)
# numpy
ctx = dict(
xs=xs, ys=ys,
fct=lambda x, y: numpy.ascontiguousarray(numpy.transpose(x, y)),
loop_fct=loop_fct)
obs = measure_time(
"loop_fct(fct, xs, ys)",
div_by_number=True, context=ctx, repeat=repeat, number=number)
obs['dim'] = dim
obs['fct'] = 'numpy'
obs.update(info)
res.append(obs)
# onnxruntime
ctx['fct'] = ort_fct
obs = measure_time(
"loop_fct(fct, xs, ys)",
div_by_number=True, context=ctx, repeat=repeat, number=number)
obs['dim'] = dim
obs['fct'] = 'ort'
obs.update(info)
res.append(obs)
if tf_transpose is not None:
# tensorflow
ctx['fct'] = tf_transpose
ctx['xs'] = [convert_to_tensor(x) for x in xs]
ctx['ys'] = [convert_to_tensor(y) for y in ys]
obs = measure_time(
"loop_fct(fct, xs, ys)",
div_by_number=True, context=ctx, repeat=repeat, number=number)
obs['dim'] = dim
obs['fct'] = 'tf'
obs.update(info)
res.append(obs)
# tensorflow with copy
ctx['fct'] = lambda x, y: tf_transpose(
convert_to_tensor(x)).numpy()
ctx['xs'] = xs
ctx['ys'] = ys
obs = measure_time(
"loop_fct(fct, xs, ys)",
div_by_number=True, context=ctx, repeat=repeat, number=number)
obs['dim'] = dim
obs['fct'] = 'tf_copy'
obs.update(info)
res.append(obs)
if torch_einsum is not None:
# torch
ctx['fct'] = lambda x, y: torch_einsum(equation, x).contiguous()
ctx['xs'] = [from_numpy(x) for x in xs]
ctx['ys'] = ys # [from_numpy(y) for y in ys]
obs = measure_time(
"loop_fct(fct, xs, ys)",
div_by_number=True, context=ctx, repeat=repeat, number=number)
obs['dim'] = dim
obs['fct'] = 'torch'
obs.update(info)
res.append(obs)
# Dataframes
shape_name = str(shape).replace(str(dim), "N")
df = pandas.DataFrame(res)
df.columns = [_.replace('dim', 'N') for _ in df.columns]
piv = df.pivot('N', 'fct', 'average')
rs = piv.copy()
for c in ['ort', 'torch', 'tf', 'tf_copy']:
if c in rs.columns:
rs[c] = rs['numpy'] / rs[c]
rs['numpy'] = 1.
# Graphs.
fig, ax = plt.subplots(1, 2, figsize=(12, 4))
piv.plot(logx=True, logy=True, ax=ax[0],
title="%s benchmark\n%r - %r - %s"
" lower better" % (name, shape_name, perm, equation))
ax[0].legend(prop={"size": 9})
rs.plot(logx=True, logy=True, ax=ax[1],
title="%s Speedup, baseline=numpy\n%r - %r - %s"
" higher better" % (name, shape_name, perm, equation))
ax[1].plot([min(rs.index), max(rs.index)], [0.5, 0.5], 'g--')
ax[1].plot([min(rs.index), max(rs.index)], [2., 2.], 'g--')
ax[1].legend(prop={"size": 9})
return df, rs, ax
dfs = []
First permutation: (1, 0, 2, 3)#
perm = (1, 0, 2, 3)
df, piv, ax = benchmark_op(perm)
dfs.append(df)
df.pivot("fct", "N", "average")
Out:
0%| | 0/11 [00:00<?, ?it/s]
9%|9 | 1/11 [00:00<00:02, 3.67it/s]
27%|##7 | 3/11 [00:01<00:03, 2.36it/s]
36%|###6 | 4/11 [00:02<00:05, 1.24it/s]
45%|####5 | 5/11 [00:05<00:07, 1.30s/it]
55%|#####4 | 6/11 [00:07<00:08, 1.65s/it]
64%|######3 | 7/11 [00:10<00:07, 1.98s/it]
73%|#######2 | 8/11 [00:11<00:05, 1.93s/it]
82%|########1 | 9/11 [00:14<00:04, 2.16s/it]
91%|######### | 10/11 [00:15<00:01, 1.84s/it]
100%|##########| 11/11 [00:17<00:00, 1.86s/it]
100%|##########| 11/11 [00:17<00:00, 1.61s/it]
Second permutation: (0, 1, 3, 2)#
perm = (1, 0, 3, 2)
df, piv, ax = benchmark_op(perm)
dfs.append(df)
df.pivot("fct", "N", "average")
Out:
0%| | 0/11 [00:00<?, ?it/s]
18%|#8 | 2/11 [00:00<00:00, 9.50it/s]
27%|##7 | 3/11 [00:01<00:05, 1.56it/s]
36%|###6 | 4/11 [00:03<00:07, 1.07s/it]
45%|####5 | 5/11 [00:05<00:08, 1.42s/it]
55%|#####4 | 6/11 [00:07<00:08, 1.75s/it]
64%|######3 | 7/11 [00:09<00:07, 1.81s/it]
73%|#######2 | 8/11 [00:12<00:06, 2.10s/it]
82%|########1 | 9/11 [00:16<00:05, 2.58s/it]
91%|######### | 10/11 [00:18<00:02, 2.37s/it]
100%|##########| 11/11 [00:21<00:00, 2.59s/it]
100%|##########| 11/11 [00:21<00:00, 1.93s/it]
Third permutation: (0, 2, 1, 3)#
This transposition is equivalent to a reshape because it only moves the empty axis. The comparison is entirely fair as the cost for onnxruntime includes a copy from numpy to onnxruntime, a reshape = another copy, than a copy back to numpy. Tensorflow and pytorch seems to have a lazy implementation in this case.
perm = (0, 2, 1, 3)
df, piv, ax = benchmark_op(perm)
dfs.append(df)
df.pivot("fct", "N", "average")
Out:
0%| | 0/11 [00:00<?, ?it/s]
27%|##7 | 3/11 [00:00<00:00, 17.19it/s]
45%|####5 | 5/11 [00:00<00:00, 8.13it/s]
64%|######3 | 7/11 [00:01<00:00, 5.14it/s]
73%|#######2 | 8/11 [00:01<00:00, 4.11it/s]
82%|########1 | 9/11 [00:02<00:00, 3.03it/s]
91%|######### | 10/11 [00:02<00:00, 3.10it/s]
100%|##########| 11/11 [00:03<00:00, 2.58it/s]
100%|##########| 11/11 [00:03<00:00, 3.64it/s]
Fourth permutation: (3, 1, 2, 0)#
perm = (3, 1, 2, 0)
df, piv, ax = benchmark_op(perm)
dfs.append(df)
df.pivot("fct", "N", "average")
Out:
0%| | 0/11 [00:00<?, ?it/s]
9%|9 | 1/11 [00:00<00:01, 6.18it/s]
18%|#8 | 2/11 [00:00<00:01, 4.52it/s]
27%|##7 | 3/11 [00:01<00:06, 1.25it/s]
36%|###6 | 4/11 [00:04<00:10, 1.48s/it]
45%|####5 | 5/11 [00:07<00:13, 2.18s/it]
55%|#####4 | 6/11 [00:12<00:14, 2.85s/it]
64%|######3 | 7/11 [00:23<00:23, 5.76s/it]
73%|#######2 | 8/11 [00:39<00:26, 8.98s/it]
82%|########1 | 9/11 [01:03<00:27, 13.67s/it]
91%|######### | 10/11 [01:15<00:13, 13.16s/it]
100%|##########| 11/11 [01:38<00:00, 16.12s/it]
100%|##########| 11/11 [01:38<00:00, 8.95s/it]
Fifth permutation: (1, 2, 3, 0)#
perm = (1, 2, 3, 0)
df, piv, ax = benchmark_op(perm)
dfs.append(df)
df.pivot("fct", "N", "average")
Out:
0%| | 0/11 [00:00<?, ?it/s]
9%|9 | 1/11 [00:00<00:01, 9.50it/s]
18%|#8 | 2/11 [00:00<00:01, 7.05it/s]
27%|##7 | 3/11 [00:01<00:06, 1.33it/s]
36%|###6 | 4/11 [00:03<00:08, 1.25s/it]
45%|####5 | 5/11 [00:06<00:10, 1.82s/it]
55%|#####4 | 6/11 [00:09<00:10, 2.13s/it]
64%|######3 | 7/11 [00:12<00:10, 2.57s/it]
73%|#######2 | 8/11 [00:16<00:08, 2.97s/it]
82%|########1 | 9/11 [00:21<00:06, 3.48s/it]
91%|######### | 10/11 [00:23<00:03, 3.05s/it]
100%|##########| 11/11 [00:26<00:00, 3.10s/it]
100%|##########| 11/11 [00:26<00:00, 2.41s/it]
Six th permutation: (1, 2, 4, 3, 0)#
perm = (1, 2, 4, 3, 0)
df, piv, ax = benchmark_op(perm, shape_fct=lambda dim: (3, dim, 1, 8, 512))
dfs.append(df)
df.pivot("fct", "N", "average")
Out:
0%| | 0/11 [00:00<?, ?it/s]
9%|9 | 1/11 [00:02<00:22, 2.22s/it]
18%|#8 | 2/11 [00:05<00:27, 3.07s/it]
27%|##7 | 3/11 [00:10<00:31, 3.98s/it]
36%|###6 | 4/11 [00:18<00:38, 5.44s/it]
45%|####5 | 5/11 [00:29<00:43, 7.29s/it]
55%|#####4 | 6/11 [00:42<00:46, 9.20s/it]
64%|######3 | 7/11 [01:01<00:49, 12.39s/it]
73%|#######2 | 8/11 [01:24<00:47, 15.99s/it]
82%|########1 | 9/11 [02:00<00:44, 22.10s/it]
91%|######### | 10/11 [02:18<00:20, 20.81s/it]
100%|##########| 11/11 [02:53<00:00, 25.15s/it]
100%|##########| 11/11 [02:53<00:00, 15.75s/it]
Conclusion#
All libraries have similar implementations. onnxruntime measures includes 2 mores copies, one to copy from numpy container to onnxruntime container, another one to copy back from onnxruntime container to numpy. Parallelisation should be investigated.
merged = pandas.concat(dfs)
name = "transpose"
merged.to_csv("plot_%s.csv" % name, index=False)
merged.to_excel("plot_%s.xlsx" % name, index=False)
plt.savefig("plot_%s.png" % name)
plt.show()
Total running time of the script: ( 5 minutes 54.786 seconds)


| PERLXSTUT(1) | Perl Programmers Reference Guide | PERLXSTUT(1) |
This tutorial starts with very simple examples and becomes more complex, with each new example adding new features. Certain concepts may not be completely explained until later in the tutorial in order to slowly ease the reader into building extensions.
This tutorial was written from a Unix point of view. Where I know them to be otherwise different for other platforms (e.g. Win32), I will list them. If you find something that was missed, please let me know.
To understand what kinds of incompatibilities one may expect, and in the rare case that the version of Perl on your machine is older than this document, see the section on "Troubleshooting these Examples" for more information.
If your extension uses some features of Perl which are not available on older releases of Perl, your users would appreciate an early meaningful warning. You would probably put this information into the README file, but nowadays installation of extensions may be performed automatically, guided by CPAN.pm module or other tools.
In MakeMaker-based installations, Makefile.PL provides the earliest opportunity to perform version checks. One can put something like this in Makefile.PL for this purpose:
eval { require 5.007 } or die <<EOD; ############ ### This module uses frobnication framework which is not available ### before version 5.007 of Perl. Upgrade your Perl before ### installing Kara::Mba. ############ EOD
This tutorial can still be used on such a system. The XSUB build mechanism will check the system and build a dynamically-loadable library if possible, or else a static library and then, optionally, a new statically-linked executable with that static library linked in.
Should you wish to build a statically-linked executable on a system which can dynamically load libraries, you may, in all the following examples, where the command ""make"" with no arguments is executed, run the command ""make perl"" instead.
If you have generated such a statically-linked executable by choice, then instead of saying ""make test"", you should say ""make test_static"". On systems that cannot build dynamically-loadable libraries at all, simply saying ""make test"" is sufficient.
For improved performance, include:
#define PERL_NO_GET_CONTEXT
as shown below.
For more details, see perlguts.
Run ""h2xs -A -n Mytest"". This creates a directory named Mytest, possibly under ext/ if that directory exists in the current working directory. Several files will be created under the Mytest dir, including MANIFEST, Makefile.PL, lib/Mytest.pm, Mytest.xs, t/Mytest.t, and Changes.
The MANIFEST file contains the names of all the files just created in the Mytest directory.
The file Makefile.PL should look something like this:
use ExtUtils::MakeMaker; # See lib/ExtUtils/MakeMaker.pm for details of how to influence # the contents of the Makefile that is written. WriteMakefile( NAME => 'Mytest', VERSION_FROM => 'Mytest.pm', # finds $VERSION LIBS => [''], # e.g., '-lm' DEFINE => '', # e.g., '-DHAVE_SOMETHING' INC => '', # e.g., '-I/usr/include/other' );
The file Mytest.pm should start with something like this:
package Mytest; use 5.008008; use strict; use warnings; require Exporter; our @ISA = qw(Exporter); our %EXPORT_TAGS = ( 'all' => [ qw( ) ] ); our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } ); our @EXPORT = qw( ); our $VERSION = '0.01'; require XSLoader; XSLoader::load('Mytest', $VERSION); # Preloaded methods go here. 1; __END__ # Below is the stub of documentation for your module. You better # edit it!
The rest of the .pm file contains sample code for providing documentation for the extension.
Finally, the Mytest.xs file should look something like this:
#define PERL_NO_GET_CONTEXT #include "EXTERN.h" #include "perl.h" #include "XSUB.h" #include "ppport.h" MODULE = Mytest PACKAGE = Mytest
Let's edit the .xs file by adding this to the end of the file:
void hello() CODE: printf("Hello, world!\n");
It is okay for the lines starting at the "CODE:" line to not be indented. However, for readability purposes, it is suggested that you indent CODE: one level and the lines following one more level.
Now we'll run ""perl Makefile.PL"". This will create a real Makefile, which make needs. Its output looks something like:
% perl Makefile.PL Checking if your kit is complete... Looks good Writing Makefile for Mytest %
Now, running make will produce output that looks something like this (some long lines have been shortened for clarity and some extraneous lines have been deleted):
% make cp lib/Mytest.pm blib/lib/Mytest.pm perl xsubpp -typemap typemap Mytest.xs > Mytest.xsc && \ mv Mytest.xsc Mytest.c Please specify prototyping behavior for Mytest.xs (see perlxs manual) cc -c Mytest.c Running Mkbootstrap for Mytest () chmod 644 Mytest.bs rm -f blib/arch/auto/Mytest/Mytest.so cc -shared -L/usr/local/lib Mytest.o -o blib/arch/auto/Mytest/Mytest.so chmod 755 blib/arch/auto/Mytest/Mytest.so cp Mytest.bs blib/arch/auto/Mytest/Mytest.bs chmod 644 blib/arch/auto/Mytest/Mytest.bs Manifying blib/man3/Mytest.3pm %
You can safely ignore the line about "prototyping behavior" - it is explained in "The PROTOTYPES: Keyword" in perlxs.
Perl has its own special way of easily writing test scripts, but for this example only, we'll create our own test script. Create a file called hello that looks like this:
#! /opt/perl5/bin/perl use ExtUtils::testlib; use Mytest; Mytest::hello();
Now we make the script executable ("chmod +x hello"), run the script and we should see the following output:
% ./hello Hello, world! %
Add the following to the end of Mytest.xs:
int is_even(input) int input CODE: RETVAL = (input % 2 == 0); OUTPUT: RETVAL
There does not need to be whitespace at the start of the ""int input"" line, but it is useful for improving readability. Placing a semi-colon at the end of that line is also optional. Any amount and kind of whitespace may be placed between the ""int"" and ""input"".
Now re-run make to rebuild our new shared library.
Now perform the same steps as before, generating a Makefile from the Makefile.PL file, and running make.
In order to test that our extension works, we now need to look at the file Mytest.t. This file is set up to imitate the same kind of testing structure that Perl itself has. Within the test script, you perform a number of tests to confirm the behavior of the extension, printing "ok" when the test is correct, "not ok" when it is not.
use Test::More tests => 4; BEGIN { use_ok('Mytest') }; ######################### # Insert your test code below, the Test::More module is use()ed here # so read its man page ( perldoc Test::More ) for help writing this # test script. is(&Mytest::is_even(0), 1); is(&Mytest::is_even(1), 0); is(&Mytest::is_even(2), 1);
We will be calling the test script through the command ""make test"". You should see output that looks something like this:
%make test PERL_DL_NONLAZY=1 /usr/bin/perl "-MExtUtils::Command::MM" "-e" "test_harness(0, 'blib/lib', 'blib/arch')" t/*.t t/Mytest....ok All tests successful. Files=1, Tests=4, 0 wallclock secs ( 0.03 cusr + 0.00 csys = 0.03 CPU) %
h2xs creates a number of files in the extension directory. The file Makefile.PL is a perl script which will generate a true Makefile to build the extension. We'll take a closer look at it later.
The .pm and .xs files contain the meat of the extension. The .xs file holds the C routines that make up the extension. The .pm file contains routines that tell Perl how to load your extension.
Generating the Makefile and running "make" created a directory called blib (which stands for "build library") in the current working directory. This directory will contain the shared library that we will build. Once we have tested it, we can install it into its final location.
Invoking the test script via ""make test"" did something very important. It invoked perl with all those "-I" arguments so that it could find the various files that are part of the extension. It is very important that while you are still testing extensions that you use ""make test"". If you try to run the test script all by itself, you will get a fatal error. Another reason it is important to use ""make test"" to run your test script is that if you are testing an upgrade to an already-existing version, using ""make test"" ensures that you will test your new extension, not the already-existing version.
When Perl sees a "use extension;", it searches for a file with the same name as the "use"'d extension that has a .pm suffix. If that file cannot be found, Perl dies with a fatal error. The default search path is contained in the @INC array.
In our case, Mytest.pm tells perl that it will need the Exporter and Dynamic Loader extensions. It then sets the @ISA and @EXPORT arrays and the $VERSION scalar; finally it tells perl to bootstrap the module. Perl will call its dynamic loader routine (if there is one) and load the shared library.
The two arrays @ISA and @EXPORT are very important. The @ISA array contains a list of other packages in which to search for methods (or subroutines) that do not exist in the current package. This is usually only important for object-oriented extensions (which we will talk about much later), and so usually doesn't need to be modified.
The @EXPORT array tells Perl which of the extension's variables and subroutines should be placed into the calling package's namespace. Because you don't know if the user has already used your variable and subroutine names, it's vitally important to carefully select what to export. Do not export method or variable names by default without a good reason.
As a general rule, if the module is trying to be object-oriented then don't export anything. If it's just a collection of functions and variables, then you can export them via another array, called @EXPORT_OK. This array does not automatically place its subroutine and variable names into the namespace unless the user specifically requests that this be done.
See perlmod for more information.
The $VERSION variable is used to ensure that the .pm file and the shared library are "in sync" with each other. Any time you make changes to the .pm or .xs files, you should increment the value of this variable.
By running ""make test"", you ensure that your Mytest.t script runs and uses the correct version of your extension. If you have many test cases, save your test files in the "t" directory and use the suffix ".t". When you run ""make test"", all of these test files will be executed.
Add the following to the end of Mytest.xs:
void round(arg) double arg CODE: if (arg > 0.0) { arg = floor(arg + 0.5); } else if (arg < 0.0) { arg = ceil(arg - 0.5); } else { arg = 0.0; } OUTPUT: arg
Edit the Makefile.PL file so that the corresponding line looks like this:
'LIBS' => ['-lm'], # e.g., '-lm'
Generate the Makefile and run make. Change the test number in Mytest.t to "9" and add the following tests:
$i = -1.5; &Mytest::round($i); is( $i, -2.0 ); $i = -1.1; &Mytest::round($i); is( $i, -1.0 ); $i = 0.0; &Mytest::round($i); is( $i, 0.0 ); $i = 0.5; &Mytest::round($i); is( $i, 1.0 ); $i = 1.2; &Mytest::round($i); is( $i, 1.0 );
Running ""make test"" should now print out that all nine tests are okay.
Notice that in these new test cases, the argument passed to round was a scalar variable. You might be wondering if you can round a constant or literal. To see what happens, temporarily add the following line to Mytest.t:
&Mytest::round(3);
Run ""make test"" and notice that Perl dies with a fatal error. Perl won't let you change the value of constants!
The list of output parameters occurs at the very end of the function, just after the OUTPUT: directive. The use of RETVAL tells Perl that you wish to send this value back as the return value of the XSUB function. In Example 3, we wanted the "return value" placed in the original variable which we passed in, so we listed it (and not RETVAL) in the OUTPUT: section.
The first section maps various C data types to a name, which corresponds somewhat with the various Perl types. The second section contains C code which xsubpp uses to handle input parameters. The third section contains C code which xsubpp uses to handle output parameters.
Let's take a look at a portion of the .c file created for our extension. The file name is Mytest.c:
XS(XS_Mytest_round) { dXSARGS; if (items != 1) Perl_croak(aTHX_ "Usage: Mytest::round(arg)"); PERL_UNUSED_VAR(cv); /* -W */ { double arg = (double)SvNV(ST(0)); /* XXXXX */ if (arg > 0.0) { arg = floor(arg + 0.5); } else if (arg < 0.0) { arg = ceil(arg - 0.5); } else { arg = 0.0; } sv_setnv(ST(0), (double)arg); /* XXXXX */ SvSETMAGIC(ST(0)); } XSRETURN_EMPTY; }
Notice the two lines commented with "XXXXX". If you check the first part of the typemap file (or section), you'll see that doubles are of type T_DOUBLE. In the INPUT part of the typemap, an argument that is T_DOUBLE is assigned to the variable arg by calling the routine SvNV on something, then casting it to double, then assigned to the variable arg. Similarly, in the OUTPUT section, once arg has its final value, it is passed to the sv_setnv function to be passed back to the calling subroutine. These two functions are explained in perlguts; we'll talk more later about what that "ST(0)" means in the section on the argument stack.
Create a new directory called Mytest2 at the same level as the directory Mytest. In the Mytest2 directory, create another directory called mylib, and cd into that directory.
Here we'll create some files that will generate a test library. These will include a C source file and a header file. We'll also create a Makefile.PL in this directory. Then we'll make sure that running make at the Mytest2 level will automatically run this Makefile.PL file and the resulting Makefile.
In the mylib directory, create a file mylib.h that looks like this:
#define TESTVAL 4 extern double foo(int, long, const char*);
Also create a file mylib.c that looks like this:
#include <stdlib.h> #include "./mylib.h" double foo(int a, long b, const char *c) { return (a + b + atof(c) + TESTVAL); }
And finally create a file Makefile.PL that looks like this:
use ExtUtils::MakeMaker; $Verbose = 1; WriteMakefile( NAME => 'Mytest2::mylib', SKIP => [qw(all static static_lib dynamic dynamic_lib)], clean => {'FILES' => 'libmylib$(LIB_EXT)'}, ); sub MY::top_targets { ' all :: static pure_all :: static static :: libmylib$(LIB_EXT) libmylib$(LIB_EXT): $(O_FILES) $(AR) cr libmylib$(LIB_EXT) $(O_FILES) $(RANLIB) libmylib$(LIB_EXT) '; }
Make sure you use a tab and not spaces on the lines beginning with "$(AR)" and "$(RANLIB)". Make will not function properly if you use spaces. It has also been reported that the "cr" argument to $(AR) is unnecessary on Win32 systems.
We will now create the main top-level Mytest2 files. Change to the directory above Mytest2 and run the following command:
% h2xs -O -n Mytest2 ./Mytest2/mylib/mylib.h
This will print out a warning about overwriting Mytest2, but that's okay. Our files are stored in Mytest2/mylib, and will be untouched.
The normal Makefile.PL that h2xs generates doesn't know about the mylib directory. We need to tell it that there is a subdirectory and that we will be generating a library in it. Let's add the argument MYEXTLIB to the WriteMakefile call so that it looks like this:
WriteMakefile( 'NAME' => 'Mytest2', 'VERSION_FROM' => 'Mytest2.pm', # finds $VERSION 'LIBS' => [''], # e.g., '-lm' 'DEFINE' => '', # e.g., '-DHAVE_SOMETHING' 'INC' => '', # e.g., '-I/usr/include/other' 'MYEXTLIB' => 'mylib/libmylib$(LIB_EXT)', );
and then at the end add a subroutine (which will override the pre-existing subroutine). Remember to use a tab character to indent the line beginning with "cd"!
sub MY::postamble { ' $(MYEXTLIB): mylib/Makefile cd mylib && $(MAKE) $(PASSTHRU) '; }
Let's also fix the MANIFEST file so that it accurately reflects the contents of our extension. The single line that says "mylib" should be replaced by the following three lines:
mylib/Makefile.PL mylib/mylib.c mylib/mylib.h
To keep our namespace nice and unpolluted, edit the .pm file and change the variable @EXPORT to @EXPORT_OK. Finally, in the .xs file, edit the #include line to read:
#include "mylib/mylib.h"
And also add the following function definition to the end of the .xs file:
double foo(a,b,c) int a long b const char * c OUTPUT: RETVAL
Now we also need to create a typemap because the default Perl doesn't currently support the "const char *" type. Include a new TYPEMAP section in your XS code before the above function:
TYPEMAP: <<END const char * T_PV END
Now run perl on the top-level Makefile.PL. Notice that it also created a Makefile in the mylib directory. Run make and watch that it does cd into the mylib directory and run make in there as well.
Now edit the Mytest2.t script and change the number of tests to "4", and add the following lines to the end of the script:
is( &Mytest2::foo(1, 2, "Hello, world!"), 7 ); is( &Mytest2::foo(1, 2, "0.0"), 7 ); ok( abs(&Mytest2::foo(0, 0, "-3.4") - 0.6) <= 0.01 );
(When dealing with floating-point comparisons, it is best to not check for equality, but rather that the difference between the expected and actual result is below a certain amount (called epsilon) which is 0.01 in this case)
Run ""make test"" and all should be well. There are some warnings on missing tests for the Mytest2::mylib extension, but you can ignore them.
MODULE = Mytest2 PACKAGE = Mytest2
Anything before this line is plain C code which describes which headers to include, and defines some convenience functions. No translations are performed on this part, apart from having embedded POD documentation skipped over (see perlpod) it goes into the generated output C file as is.
Anything after this line is the description of XSUB functions. These descriptions are translated by xsubpp into C code which implements these functions using Perl calling conventions, and which makes these functions visible from Perl interpreter.
Pay a special attention to the function "constant". This name appears twice in the generated .xs file: once in the first part, as a static C function, then another time in the second part, when an XSUB interface to this static C function is defined.
This is quite typical for .xs files: usually the .xs file provides an interface to an existing C function. Then this C function is defined somewhere (either in an external library, or in the first part of .xs file), and a Perl interface to this function (i.e. "Perl glue") is described in the second part of .xs file. The situation in "EXAMPLE 1", "EXAMPLE 2", and "EXAMPLE 3", when all the work is done inside the "Perl glue", is somewhat of an exception rather than the rule.
double foo(a,b,c) int a long b const char * c OUTPUT: RETVAL
Note that in contrast with "EXAMPLE 1", "EXAMPLE 2" and "EXAMPLE 3", this description does not contain the actual code for what is done during a call to Perl function foo(). To understand what is going on here, one can add a CODE section to this XSUB:
double foo(a,b,c) int a long b const char * c CODE: RETVAL = foo(a,b,c); OUTPUT: RETVAL
However, these two XSUBs provide almost identical generated C code: xsubpp compiler is smart enough to figure out the "CODE:" section from the first two lines of the description of XSUB. What about "OUTPUT:" section? In fact, that is absolutely the same! The "OUTPUT:" section can be removed as well, as far as "CODE:" section or "PPCODE:" section is not specified: xsubpp can see that it needs to generate a function call section, and will autogenerate the OUTPUT section too. Thus one can shortcut the XSUB to become:
double foo(a,b,c) int a long b const char * c
Can we do the same with an XSUB
int is_even(input) int input CODE: RETVAL = (input % 2 == 0); OUTPUT: RETVAL
of "EXAMPLE 2"? To do this, one needs to define a C function "int is_even(int input)". As we saw in "Anatomy of .xs file", a proper place for this definition is in the first part of .xs file. In fact a C function
int is_even(int arg) { return (arg % 2 == 0); }
is probably overkill for this. Something as simple as a "#define" will do too:
#define is_even(arg) ((arg) % 2 == 0)
After having this in the first part of .xs file, the "Perl glue" part becomes as simple as
int is_even(input) int input
This technique of separation of the glue part from the workhorse part has obvious tradeoffs: if you want to change a Perl interface, you need to change two places in your code. However, it removes a lot of clutter, and makes the workhorse part independent from idiosyncrasies of Perl calling convention. (In fact, there is nothing Perl-specific in the above description, a different version of xsubpp might have translated this to TCL glue or Python glue as well.)
When you specify arguments to routines in the .xs file, you are really passing three pieces of information for each argument listed. The first piece is the order of that argument relative to the others (first, second, etc). The second is the type of argument, and consists of the type declaration of the argument (e.g., int, char*, etc). The third piece is the calling convention for the argument in the call to the library function.
While Perl passes arguments to functions by reference, C passes arguments by value; to implement a C function which modifies data of one of the "arguments", the actual argument of this C function would be a pointer to the data. Thus two C functions with declarations
int string_length(char *s); int upper_case_char(char *cp);
may have completely different semantics: the first one may inspect an array of chars pointed by s, and the second one may immediately dereference "cp" and manipulate *cp only (using the return value as, say, a success indicator). From Perl one would use these functions in a completely different manner.
One conveys this info to xsubpp by replacing "*" before the argument by "&". "&" means that the argument should be passed to a library function by its address. The above two function may be XSUB-ified as
int string_length(s) char * s int upper_case_char(cp) char &cp
For example, consider:
int foo(a,b) char &a char * b
The first Perl argument to this function would be treated as a char and assigned to the variable a, and its address would be passed into the function foo. The second Perl argument would be treated as a string pointer and assigned to the variable b. The value of b would be passed into the function foo. The actual call to the function foo that xsubpp generates would look like this:
foo(&a, b);
xsubpp will parse the following function argument lists identically:
char &a char&a char & a
However, to help ease understanding, it is suggested that you place a "&" next to the variable name and away from the variable type), and place a "*" near the variable type, but away from the variable name (as in the call to foo above). By doing so, it is easy to understand exactly what will be passed to the C function; it will be whatever is in the "last column".
You should take great pains to try to pass the function the type of variable it wants, when possible. It will save you a lot of trouble in the long run.
When you list the arguments to the XSUB in the .xs file, that tells xsubpp which argument corresponds to which of the argument stack (i.e., the first one listed is the first argument, and so on). You invite disaster if you do not list them in the same order as the function expects them.
The actual values on the argument stack are pointers to the values passed in. When an argument is listed as being an OUTPUT value, its corresponding value on the stack (i.e., ST(0) if it was the first argument) is changed. You can verify this by looking at the C code generated for Example 3. The code for the round() XSUB routine contains lines that look like this:
double arg = (double)SvNV(ST(0)); /* Round the contents of the variable arg */ sv_setnv(ST(0), (double)arg);
The arg variable is initially set by taking the value from ST(0), then is stored back into ST(0) at the end of the routine.
XSUBs are also allowed to return lists, not just scalars. This must be done by manipulating stack values ST(0), ST(1), etc, in a subtly different way. See perlxs for details.
XSUBs are also allowed to avoid automatic conversion of Perl function arguments to C function arguments. See perlxs for details. Some people prefer manual conversion by inspecting ST(i) even in the cases when automatic conversion will do, arguing that this makes the logic of an XSUB call clearer.
While experts may argue about these idioms, a novice to Perl guts may prefer a way which is as little Perl-guts-specific as possible, meaning automatic conversion and automatic call generation, as in "Getting the fat out of XSUBs". This approach has the additional benefit of protecting the XSUB writer from future changes to the Perl API.
You may intersperse documentation and Perl code within the .pm file. In fact, if you want to use method autoloading, you must do this, as the comment inside the .pm file explains.
See perlpod for more information about the pod format.
Alternately, you can specify the exact directory to place the extension's files by placing a "PREFIX=/destination/directory" after the make install (or in between the make and install if you have a brain-dead version of make). This can be very useful if you are building an extension that will eventually be distributed to multiple systems. You can then just archive the files in the destination directory and distribute them to your destination systems.
This extension is very Unix-oriented (struct statfs and the statfs system call). If you are not running on a Unix system, you can substitute for statfs any other function that returns multiple values, you can hard-code values to be returned to the caller (although this will be a bit harder to test the error case), or you can simply not do this example. If you change the XSUB, be sure to fix the test cases to match the changes.
Return to the Mytest directory and add the following code to the end of Mytest.xs:
void statfs(path) char * path INIT: int i; struct statfs buf; PPCODE: i = statfs(path, &buf); if (i == 0) { XPUSHs(sv_2mortal(newSVnv(buf.f_bavail))); XPUSHs(sv_2mortal(newSVnv(buf.f_bfree))); XPUSHs(sv_2mortal(newSVnv(buf.f_blocks))); XPUSHs(sv_2mortal(newSVnv(buf.f_bsize))); XPUSHs(sv_2mortal(newSVnv(buf.f_ffree))); XPUSHs(sv_2mortal(newSVnv(buf.f_files))); XPUSHs(sv_2mortal(newSVnv(buf.f_type))); } else { XPUSHs(sv_2mortal(newSVnv(errno))); }
You'll also need to add the following code to the top of the .xs file, just after the include of "XSUB.h":
#include <sys/vfs.h>
Also add the following code segment to Mytest.t while incrementing the "9" tests to "11":
@a = &Mytest::statfs("/blech"); ok( scalar(@a) == 1 && $a[0] == 2 ); @a = &Mytest::statfs("/"); is( scalar(@a), 7 );
We do this by using the PPCODE: directive, rather than the CODE: directive. This tells xsubpp that we will be managing the return values that will be put on the argument stack by ourselves.
The XPUSH* macros will automatically extend the return stack to prevent it from being overrun. You push values onto the stack in the order you want them seen by the calling program.
EXTEND(SP, 7);
The tradeoff is that one needs to calculate the number of return values in advance (though overextending the stack will not typically hurt anything but memory consumption).
Similarly, in the failure branch we could use "PUSHs" without extending the stack: the Perl function reference comes to an XSUB on the stack, thus the stack is always large enough to take one return value.
This extension is somewhat contrived. It is based on the code in the previous example. It calls the statfs function multiple times, accepting a reference to an array of filenames as input, and returning a reference to an array of hashes containing the data for each of the filesystems.
Return to the Mytest directory and add the following code to the end of Mytest.xs:
SV * multi_statfs(paths) SV * paths INIT: AV * results; SSize_t numpaths = 0, n; int i; struct statfs buf; SvGETMAGIC(paths); if ((!SvROK(paths)) || (SvTYPE(SvRV(paths)) != SVt_PVAV) || ((numpaths = av_top_index((AV *)SvRV(paths))) < 0)) { XSRETURN_UNDEF; } results = (AV *)sv_2mortal((SV *)newAV()); CODE: for (n = 0; n <= numpaths; n++) { HV * rh; STRLEN l; char * fn = SvPV(*av_fetch((AV *)SvRV(paths), n, 0), l); i = statfs(fn, &buf); if (i != 0) { av_push(results, newSVnv(errno)); continue; } rh = (HV *)sv_2mortal((SV *)newHV()); hv_store(rh, "f_bavail", 8, newSVnv(buf.f_bavail), 0); hv_store(rh, "f_bfree", 7, newSVnv(buf.f_bfree), 0); hv_store(rh, "f_blocks", 8, newSVnv(buf.f_blocks), 0); hv_store(rh, "f_bsize", 7, newSVnv(buf.f_bsize), 0); hv_store(rh, "f_ffree", 7, newSVnv(buf.f_ffree), 0); hv_store(rh, "f_files", 7, newSVnv(buf.f_files), 0); hv_store(rh, "f_type", 6, newSVnv(buf.f_type), 0); av_push(results, newRV_inc((SV *)rh)); } RETVAL = newRV_inc((SV *)results); OUTPUT: RETVAL
And add the following code to Mytest.t, while incrementing the "11" tests to "13":
$results = Mytest::multi_statfs([ '/', '/blech' ]); ok( ref $results->[0] ); ok( ! ref $results->[1] );
Specifically, we read pathnames one at a time from the input array, and store the results in an output array (results) in the same order. If statfs fails, the element pushed onto the return array is the value of errno after the failure. If statfs succeeds, though, the value pushed onto the return array is a reference to a hash containing some of the information in the statfs structure.
As with the return stack, it would be possible (and a small performance win) to pre-extend the return array before pushing data into it, since we know how many elements we will return:
av_extend(results, numpaths);
Suppose that for some strange reason we need a wrapper around the standard C library function "fputs()". This is all we need:
#define PERLIO_NOT_STDIO 0 #define PERL_NO_GET_CONTEXT #include "EXTERN.h" #include "perl.h" #include "XSUB.h" #include <stdio.h> int fputs(s, stream) char * s FILE * stream
The real work is done in the standard typemap.
But you lose all the fine stuff done by the perlio layers. This calls the stdio function "fputs()", which knows nothing about them.
The standard typemap offers three variants of PerlIO *: "InputStream" (T_IN), "InOutStream" (T_INOUT) and "OutputStream" (T_OUT). A bare "PerlIO *" is considered a T_INOUT. If it matters in your code (see below for why it might) #define or typedef one of the specific names and use that as the argument or result type in your XS file.
The standard typemap does not contain PerlIO * before perl 5.7, but it has the three stream variants. Using a PerlIO * directly is not backwards compatible unless you provide your own typemap.
For streams coming from perl the main difference is that "OutputStream" will get the output PerlIO * - which may make a difference on a socket. Like in our example...
For streams being handed to perl a new file handle is created (i.e. a reference to a new glob) and associated with the PerlIO * provided. If the read/write state of the PerlIO * is not correct then you may get errors or warnings from when the file handle is used. So if you opened the PerlIO * as "w" it should really be an "OutputStream" if open as "r" it should be an "InputStream".
 We'll use the perlio "PerlIO_puts()" function as an example.
In the C part of the XS file (above the first MODULE line) you have
#define OutputStream PerlIO * or typedef PerlIO * OutputStream;
And this is the XS code:
int perlioputs(s, stream) char * s OutputStream stream CODE: RETVAL = PerlIO_puts(stream, s); OUTPUT: RETVAL
We have to use a "CODE" section because "PerlIO_puts()" has the arguments reversed compared to "fputs()", and we want to keep the arguments the same.
Wanting to explore this thoroughly, we want to use the stdio "fputs()" on a PerlIO *. This means we have to ask the perlio system for a stdio "FILE *":
int perliofputs(s, stream) char * s OutputStream stream PREINIT: FILE *fp = PerlIO_findFILE(stream); CODE: if (fp != (FILE*) 0) { RETVAL = fputs(s, fp); } else { RETVAL = -1; } OUTPUT: RETVAL
Note: "PerlIO_findFILE()" will search the layers for a stdio layer. If it can't find one, it will call "PerlIO_exportFILE()" to generate a new stdio "FILE". Please only call "PerlIO_exportFILE()" if you want a new "FILE". It will generate one on each call and push a new stdio layer. So don't call it repeatedly on the same file. "PerlIO_findFILE()" will retrieve the stdio layer once it has been generated by "PerlIO_exportFILE()".
This applies to the perlio system only. For versions before 5.7, "PerlIO_exportFILE()" is equivalent to "PerlIO_findFILE()".
use lib './blib';
use lib './blib';
BEGIN { unshift(@INC, "./blib") }
Reviewed and assisted by Dean Roehrich, Ilya Zakharevich, Andreas Koenig, and Tim Bunce.
PerlIO material contributed by Lupe Christoph, with some clarification by Nick Ing-Simmons.
Changes for h2xs as of Perl 5.8.x by Renee Baecker
| 2019-10-21 | perl v5.30.3 |


| Class | ResultGroupField |
| In: |
lib/result_group_field.rb
|
| Parent: | Object |
Purpose: Maintain basic information about fields in a structured way, that can be used to group search results.
| attribute_name | [RW] | Allow read/write access to the main attributes |
| display_name | [RW] | Allow read/write access to the main attributes |
| field_name | [RW] | Allow read/write access to the main attributes |
Purpose: Create a new ResultGroupField Input:
** display_name (string) - The name of the field as it should be displayed to the user ** attribute_name (string) - The name of the attribute which cooresponds to this field. The attribute name should be used to get the correct value from the model, instead of the field name.


I am an Enterprise Architect working in the aerospace industry. I have been employed in the business of building software applications for a very long time. I have programmed in more languages than I can remember on numerous computers and operating systems. I am a "data wonk" who has focused on databases, business intelligence, and analytics for the last 20+ years.
One of my current projects involves data integration between an externally hosted application and an internally hosted application using Apache Kafka as the transport mechanism. It has turned out to be very interesting and quite challenging


This example demonstrates at hand of a double pendulum, how non-standard initialization can be defined: The absolute position of the pendulum tip, and its absolute speed shall be initially defined. This can be performed with the Joints.FreeMotionScalarInit joint that allows to initialize individual elements of its relative vectors. In this case, the x-, and y-coordinates of the relative position vector (visualized by the yellow arrow in the figure below) and of its derivative shall have a defined value at initial time. The configuration of the double pendulum at the initial time is shown below, where the tip position is required to have the coordinates x=0.7, y=0.3.
Setting only the tip's start position results in an ambiguous
initialization since two valid solutions for
revolute1.phi
and revolute2.phi
exist.
Moreover, the calculated angles revolute1.phi
and
revolute2.phi
can be a multiple of expected solution
phi1
and phi2
,
To clearly indicate the preferred solution, guess initial angles
can be additionally given. In this example, it is simply done by
revolute2.phi.start = Modelica.Constants.pi/2
.


Name should contains only letters
Each macronutrient should be between 0 and 100
Sum of macronutrients can't be greater than 100


This module you can use in your web pages and it will allows you to capture information that you have appended to a URL. Please see this article for further details
{module_url,variable}
{module_url,question}
- assuming the URL is mysite.com?question=how_are_you this module will display in plain text How_are_you


Order Now
View Products
DON'T PANIC. IT'S ORGANIC. BUT THISS WILL SURELY MAKE YA'LL ADIK.
Browse gallery


飞翔的面包
Software Engineer at Didi, Inc.
Beijing City, China | Computer Software
Education: XDU
scholar, CS/IT
Social: github
Contact:
System.out.format("%s@gmail.com\n","zlzdbf");
Note:
public class Thanks
{
public static void main(String[] args) {
System.out.println(" Hello,friends !");
System.out.println(" Thanks for code, make me meet the world !");
}
}


Initiative of Robotics Lab, Dept. of CSE, University of Dhaka
Financed by Ministry of Education, Govt. of Bangladesh


Our community started from a unique survival Minecraft server focused on building. We have been going strong for over 7 years with no stop in sight. Our goal is to build community one block at a time. Join today to build friendships and buildings.
More About UsSurvival Minecraft Server IP: MagnaRisa.Pxcnet.com
We pride ourselves in our mission to create a safe and family friendly enviornment for all to enjoy. From the rules to the people they attract, it is good enough you bring us home to your mamma!
Our frequent building events give players the opportunity to showcase their building skills. Materials are never spawned in and always hand gathered by someone on the server. Don't delay, join today for an excelently legit experience!
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Rem magni quas ex numquam, maxime minus quam molestias corporis quod, ea minima accusamus.


NBA Most Valueable Player Award
|
NBA Rookie of The Year Award
|
Best Male Athlete ESPY Award
|
Best NBA Player ESPY Award
|
Presidential Medal of Freedom
|
Sports Illustrated Sportsperson of the Year
|
NBA Defensive Player of the Year Award
|
Adolph Rupp Trophy
|
NBA All Star Game Most Valueable Player Award
|


Jane McDonald's stunned response at becoming Adele Roberts' luxury item on I'm A Celeb
The Radio 1 DJ picked a photo of the Loose Women star to be her luxury item during her stint in the jungle
by Lucy Needham, https://www.facebook.com/dailymirror/Jane McDonald has responded after she became the unlikely inspiration for Adele Roberts' luxury item on this year's I'm A Celebrity.
On Tuesday night's episode, the famous faces in the main camp were tasked with retrieving the goods they selected prior to show over a pond - with nothing but oars to help them.
As they tried to grab each parcel in turn the items each celebrity had picked to bring them comfort for the foreseeable future were revealed.
Kate Garraway chose concealer, James Haskell an orthopaedic pillow and Roman Kemp plumped for a mug with a picture of his family on it.
Radio 1 DJ Adele plumped for something a little more bizarre.
She told her fellow campmates that she'd selected a picture of Loose Women star and cruise ship legend Jane McDonald to bring her support during her stint Down Under.
Adele said she was huge fan of Jane's work and after the photo was successfully obtained encouraged her pals to 'give Jane a rub for luck.'
Jane has now responded after her surprise cameo in the jungle.
Taking to Twitter , Jane wrote: "Absolutely thrilled to see my picture in the jungle. Adele Roberts I flipping love you," followed by a red love heart.
She then revealed that she'd be supporting her fellow Notherner in the jungle, "Best of luck," added Jane.
Adele's pick had come as a surprise to her campmates and viewers at home with celebs usually opting for something practical to make their time in the jungle that little bit easier.
The broadcaster was one of only two celebs to receive their goodies from home - with Kate Garraway also getting her hands on her make-up - after the team failed miserably at their attempts to save the luxury items before they sank.
The celebs in the spin off camp, who have been living on basic rations, were particularly upset to see hear of the watery demise of their home comforts.


Mailman.Render
Functions for rendering email messages into strings
Summary
| as_list(value) | |
| compile_part(type, email, composer) | |
| compile_parts(email, composer) | |
| content_type_params_for(attachment) | |
| disposition_for(attachment) | |
| disposition_params_for(attachment) | |
| headers_for(email) | |
| mime_subtype_for(parts) | |
| mime_type_for(parts) | |
| normalize_addresses(addresses) | |
| not_empty_tuple_value(tuple) | Returns boolean saying if a value for a tuple is blank as a string or list |
| parameters_for(arg1) | |
| render(email, composer) | Returns a tuple with all data needed for the underlying adapter to send |
| to_tuple(part, email) |


Vim documentation: gui
main help file*gui.txt* For Vim version 7.2. Last change: 2008 Jun 14 VIM REFERENCE MANUAL by Bram Moolenaar Vim's Graphical User Interface *gui* *GUI* 1. Starting the GUI |gui-start| 2. Scrollbars |gui-scrollbars| 3. Mouse Control |gui-mouse| 4. Making GUI Selections |gui-selections| 5. Menus |menus| 6. Extras |gui-extras| 7. Shell Commands |gui-shell| Other GUI documentation: |gui_x11.txt| For specific items of the X11 GUI. |gui_w32.txt| For specific items of the Win32 GUI. {Vi does not have any of these commands}
1. Starting the GUI *gui-start* *E229* *E233* First you must make sure you actually have a version of Vim with the GUI code included. You can check this with the ":version" command, it says "with xxx GUI", where "xxx" is X11-Motif, X11-Athena, Photon, GTK, GTK2, etc., or "MS-Windows 32 bit GUI version". How to start the GUI depends on the system used. Mostly you can run the GUI version of Vim with: gvim [options] [files...] The X11 version of Vim can run both in GUI and in non-GUI mode. See |gui-x11-start|. *gui-init* *gvimrc* *.gvimrc* *_gvimrc* The gvimrc file is where GUI-specific startup commands should be placed. It is always sourced after the |vimrc| file. If you have one then the $MYGVIMRC environment variable has its name. When the GUI starts up initializations are carried out, in this order: - The 'term' option is set to "builgin_gui" and terminal options are reset to their default value for the GUI |terminal-options|. - If the system menu file exists, it is sourced. The name of this file is normally "$VIMRUNTIME/menu.vim". You can check this with ":version". Also see |$VIMRUNTIME|. To skip loading the system menu include 'M' in 'guioptions'. *buffers-menu* *no_buffers_menu* The system menu file includes a "Buffers" menu. If you don't want this, set the "no_buffers_menu" variable in your .vimrc (not .gvimrc!): :let no_buffers_menu = 1 NOTE: Switching on syntax highlighting also loads the menu file, thus disabling the Buffers menu must be done before ":syntax on". The path names are truncated to 35 characters. You can truncate them at a different length, for example 50, like this: :let bmenu_max_pathlen = 50 - If the "-U {gvimrc}" command-line option has been used when starting Vim, the {gvimrc} file will be read for initializations. The following initializations are skipped. When {gvimrc} is "NONE" no file will be read for initializations. - For Unix and MS-Windows, if the system gvimrc exists, it is sourced. The name of this file is normally "$VIM/gvimrc". You can check this with ":version". Also see |$VIM|. - The following are tried, and only the first one that exists is used: - If the GVIMINIT environment variable exists and is not empty, it is executed as an Ex command. - If the user gvimrc file exists, it is sourced. The name of this file is normally "$HOME/.gvimrc". You can check this with ":version". - For Win32, when $HOME is not set, "$VIM\_gvimrc" is used. - When a "_gvimrc" file is not found, ".gvimrc" is tried too. And vice versa. The name of the first file found is stored in $MYGVIMRC, unless it was already set. - If the 'exrc' option is set (which is NOT the default) the file ./.gvimrc is sourced, if it exists and isn't the same file as the system or user gvimrc file. If this file is not owned by you, some security restrictions apply. When ".gvimrc" is not found, "_gvimrc" is tried too. For Macintosh and DOS/Win32 "_gvimrc" is tried first. NOTE: All but the first one are not carried out if Vim was started with "-u NONE" and no "-U" argument was given, or when started with "-U NONE". All this happens AFTER the normal Vim initializations, like reading your .vimrc file. See |initialization|. But the GUI window is only opened after all the initializations have been carried out. If you want some commands to be executed just after opening the GUI window, use the |GUIEnter| autocommand event. Example: :autocmd GUIEnter * winpos 100 50 You can use the gvimrc files to set up your own customized menus (see |:menu|) and initialize other things that you may want to set up differently from the terminal version. Recommended place for your personal GUI initializations: Unix $HOME/.gvimrc OS/2 $HOME/.gvimrc or $VIM/.gvimrc MS-DOS and Win32 $HOME/_gvimrc or $VIM/_gvimrc Amiga s:.gvimrc or $VIM/.gvimrc There are a number of options which only have meaning in the GUI version of Vim. These are 'guicursor', 'guifont', 'guipty' and 'guioptions'. They are documented in |options.txt| with all the other options. If using the Motif or Athena version of the GUI (but not for the GTK+ or Win32 version), a number of X resources are available. See |gui-resources|. Another way to set the colors for different occasions is with highlight groups. The "Normal" group is used to set the background and foreground colors. Example (which looks nice): :highlight Normal guibg=grey90 The "guibg" and "guifg" settings override the normal background and foreground settings. The other settings for the Normal highlight group are not used. Use the 'guifont' option to set the font. Also check out the 'guicursor' option, to set the colors for the cursor in various modes. Vim tries to make the window fit on the screen when it starts up. This avoids that you can't see part of it. On the X Window System this requires a bit of guesswork. You can change the height that is used for the window title and a task bar with the 'guiheadroom' option. *:winp* *:winpos* *E188* :winp[os] Display current position of the top left corner of the GUI vim window in pixels. Does not work in all versions. :winp[os] {X} {Y} *E466* Put the GUI vim window at the given {X} and {Y} coordinates. The coordinates should specify the position in pixels of the top left corner of the window. Does not work in all versions. Does work in an (new) xterm |xterm-color|. When the GUI window has not been opened yet, the values are remembered until the window is opened. The position is adjusted to make the window fit on the screen (if possible). *:win* *:winsize* *E465* :win[size] {width} {height} Set the window height to {width} by {height} characters. Obsolete, use ":set lines=11 columns=22". If you get less lines than expected, check the 'guiheadroom' option. If you are running the X Window System, you can get information about the window Vim is running in with this command: :!xwininfo -id $WINDOWID
2. Scrollbars *gui-scrollbars* There are vertical scrollbars and a horizontal scrollbar. You may configure which ones appear with the 'guioptions' option. The interface looks like this (with ":set guioptions=mlrb"): +------------------------------+ | File Edit Help | <- Menu bar (m) +-+--------------------------+-+ |^| |^| |#| Text area. |#| | | | | |v|__________________________|v| Normal status line -> |-+ File.c 5,2 +-| between Vim windows |^|""""""""""""""""""""""""""|^| | | | | | | Another file buffer. | | | | | | |#| |#| Left scrollbar (l) -> |#| |#| <- Right |#| |#| scrollbar (r) | | | | |v| |v| +-+--------------------------+-+ | |< #### >| | <- Bottom +-+--------------------------+-+ scrollbar (b) Any of the scrollbar or menu components may be turned off by not putting the appropriate letter in the 'guioptions' string. The bottom scrollbar is only useful when 'nowrap' is set. VERTICAL SCROLLBARS *gui-vert-scroll* Each Vim window has a scrollbar next to it which may be scrolled up and down to move through the text in that buffer. The size of the scrollbar-thumb indicates the fraction of the buffer which can be seen in the window. When the scrollbar is dragged all the way down, the last line of the file will appear in the top of the window. If a window is shrunk to zero height (by the growth of another window) its scrollbar disappears. It reappears when the window is restored. If a window is vertically split, it will get a scrollbar when it is the current window and when, taking the middle of the current window and drawing a vertical line, this line goes through the window. When there are scrollbars on both sides, and the middle of the current window is on the left half, the right scrollbar column will contain scrollbars for the rightmost windows. The same happens on the other side. HORIZONTAL SCROLLBARS *gui-horiz-scroll* The horizontal scrollbar (at the bottom of the Vim GUI) may be used to scroll text sideways when the 'wrap' option is turned off. The scrollbar-thumb size is such that the text of the longest visible line may be scrolled as far as possible left and right. The cursor is moved when necessary, it must remain on a visible character (unless 'virtualedit' is set). Computing the length of the longest visible line takes quite a bit of computation, and it has to be done every time something changes. If this takes too much time or you don't like the cursor jumping to another line, include the 'h' flag in 'guioptions'. Then the scrolling is limited by the text of the current cursor line. *athena-intellimouse* If you have an Intellimouse and an X server that supports using the wheel, then you can use the wheel to scroll the text up and down in gvim. This works with XFree86 4.0 and later, and with some older versions when you add patches. See |scroll-mouse-wheel|. For older versions of XFree86 you must patch your X server. The following page has a bit of information about using the Intellimouse on Linux as well as links to the patches and X server binaries (may not have the one you need though): http://www.inria.fr/koala/colas/mouse-wheel-scroll/
3. Mouse Control *gui-mouse* The mouse only works if the appropriate flag in the 'mouse' option is set. When the GUI is switched on, and 'mouse' wasn't set yet, the 'mouse' option is automatically set to "a", enabling it for all modes except for the |hit-enter| prompt. If you don't want this, a good place to change the 'mouse' option is the "gvimrc" file. Other options that are relevant: 'mousefocus' window focus follows mouse pointer |gui-mouse-focus| 'mousemodel' what mouse button does which action 'mousehide' hide mouse pointer while typing text 'selectmode' whether to start Select mode or Visual mode A quick way to set these is with the ":behave" command. *:behave* *:be* :be[have] {model} Set behavior for mouse and selection. Valid arguments are: mswin MS-Windows behavior xterm Xterm behavior Using ":behave" changes these options: option mswin xterm 'selectmode' "mouse,key" "" 'mousemodel' "popup" "extend" 'keymodel' "startsel,stopsel" "" 'selection' "exclusive" "inclusive" In the $VIMRUNTIME directory, there is a script called |mswin.vim|, which will also map a few keys to the MS-Windows cut/copy/paste commands. This is NOT compatible, since it uses the CTRL-V, CTRL-X and CTRL-C keys. If you don't mind, use this command: :so $VIMRUNTIME/mswin.vim For scrolling with a wheel on a mouse, see |scroll-mouse-wheel|. 3.1 Moving Cursor with Mouse *gui-mouse-move* Click the left mouse button somewhere in a text buffer where you want the cursor to go, and it does! This works in when 'mouse' contains Normal mode 'n' or 'a' Visual mode 'v' or 'a' Insert mode 'i' or 'a' Select mode is handled like Visual mode. You may use this with an operator such as 'd' to delete text from the current cursor position to the position you point to with the mouse. That is, you hit 'd' and then click the mouse somewhere. *gui-mouse-focus* The 'mousefocus' option can be set to make the keyboard focus follow the mouse pointer. This means that the window where the mouse pointer is, is the active window. Warning: this doesn't work very well when using a menu, because the menu command will always be applied to the top window. If you are on the ':' line (or '/' or '?'), then clicking the left or right mouse button will position the cursor on the ':' line (if 'mouse' contains 'c', 'a' or 'A'). In any situation the middle mouse button may be clicked to paste the current selection. 3.2 Selection with Mouse *gui-mouse-select* The mouse can be used to start a selection. How depends on the 'mousemodel' option: 'mousemodel' is "extend": use the right mouse button 'mousemodel' is "popup": use the left mouse button, while keeping the Shift key pressed. If there was no selection yet, this starts a selection from the old cursor position to the position pointed to with the mouse. If there already is a selection then the closest end will be extended. If 'selectmode' contains "mouse", then the selection will be in Select mode. This means that typing normal text will replace the selection. See |Select-mode|. Otherwise, the selection will be in Visual mode. Double clicking may be done to make the selection word-wise, triple clicking makes it line-wise, and quadruple clicking makes it rectangular block-wise. See |gui-selections| on how the selection is used. 3.3 Other Text Selection with Mouse *gui-mouse-modeless* *modeless-selection* A different kind of selection is used when: - in Command-line mode - in the Command-line window and pointing in another window - at the |hit-enter| prompt - whenever the current mode is not in the 'mouse' option - when holding the CTRL and SHIFT keys in the GUI Since Vim continues like the selection isn't there, and there is no mode associated with the selection, this is called modeless selection. Any text in the Vim window can be selected. Select the text by pressing the left mouse button at the start, drag to the end and release. To extend the selection, use the right mouse button when 'mousemodel' is "extend", or the left mouse button with the shift key pressed when 'mousemodel' is "popup". The selection is removed when the selected text is scrolled or changed. On the command line CTRL-Y can be used to copy the selection into the clipboard. To do this from Insert mode, use CTRL-O : CTRL-Y <CR>. When 'guioptions' contains a or A (default on X11), the selection is automatically copied to the "* register. The middle mouse button can then paste the text. On non-X11 systems, you can use CTRL-R +. 3.4 Using Mouse on Status Lines *gui-mouse-status* Clicking the left or right mouse button on the status line below a Vim window makes that window the current window. This actually happens on button release (to be able to distinguish a click from a drag action). With the left mouse button a status line can be dragged up and down, thus resizing the windows above and below it. This does not change window focus. The same can be used on the vertical separator: click to give the window left of it focus, drag left and right to make windows wider and narrower. 3.5 Various Mouse Clicks *gui-mouse-various* <S-LeftMouse> Search forward for the word under the mouse click. When 'mousemodel' is "popup" this starts or extends a selection. <S-RightMouse> Search backward for the word under the mouse click. <C-LeftMouse> Jump to the tag name under the mouse click. <C-RightMouse> Jump back to position before the previous tag jump (same as "CTRL-T") 3.6 Mouse Mappings *gui-mouse-mapping* The mouse events, complete with modifiers, may be mapped. Eg: :map <S-LeftMouse> <RightMouse> :map <S-LeftDrag> <RightDrag> :map <S-LeftRelease> <RightRelease> :map <2-S-LeftMouse> <2-RightMouse> :map <2-S-LeftDrag> <2-RightDrag> :map <2-S-LeftRelease> <2-RightRelease> :map <3-S-LeftMouse> <3-RightMouse> :map <3-S-LeftDrag> <3-RightDrag> :map <3-S-LeftRelease> <3-RightRelease> :map <4-S-LeftMouse> <4-RightMouse> :map <4-S-LeftDrag> <4-RightDrag> :map <4-S-LeftRelease> <4-RightRelease> These mappings make selection work the way it probably should in a Motif application, with shift-left mouse allowing for extending the visual area rather than the right mouse button. Mouse mapping with modifiers does not work for modeless selection. 3.7 Drag and drop *drag-n-drop* You can drag and drop one or more files into the Vim window, where they will be opened as if a |:drop| command was used. If you hold down Shift while doing this, Vim changes to the first dropped file's directory. If you hold Ctrl Vim will always split a new window for the file. Otherwise it's only done if the current buffer has been changed. You can also drop a directory on Vim. This starts the explorer plugin for that directory (assuming it was enabled, otherwise you'll get an error message). Keep Shift pressed to change to the directory instead. If Vim happens to be editing a command line, the names of the dropped files and directories will be inserted at the cursor. This allows you to use these names with any Ex command. Special characters (space, tab, double quote and '|'; backslash on non-MS-Windows systems) will be escaped.
4. Making GUI Selections *gui-selections* *quotestar* You may make selections with the mouse (see |gui-mouse-select|), or by using Vim's Visual mode (see |v|). If 'a' is present in 'guioptions', then whenever a selection is started (Visual or Select mode), or when the selection is changed, Vim becomes the owner of the windowing system's primary selection (on MS-Windows the |gui-clipboard| is used; under X11, the |x11-selection| is used - you should read whichever of these is appropriate now). *clipboard* There is a special register for storing this selection, it is the "* register. Nothing is put in here unless the information about what text is selected is about to change (e.g. with a left mouse click somewhere), or when another application wants to paste the selected text. Then the text is put in the "* register. For example, to cut a line and make it the current selection/put it on the clipboard: "*dd Similarly, when you want to paste a selection from another application, e.g., by clicking the middle mouse button, the selection is put in the "* register first, and then 'put' like any other register. For example, to put the selection (contents of the clipboard): "*p When using this register under X11, also see |x11-selection|. This also explains the related "+ register. Note that when pasting text from one Vim into another separate Vim, the type of selection (character, line, or block) will also be copied. For other applications the type is always character. However, if the text gets transferred via the |x11-cut-buffer|, the selection type is ALWAYS lost. When the "unnamed" string is included in the 'clipboard' option, the unnamed register is the same as the "* register. Thus you can yank to and paste the selection without prepending "* to commands.
5. Menus *menus* For an introduction see |usr_42.txt| in the user manual. 5.1 Using Menus *using-menus* Basically, menus can be used just like mappings. You can define your own menus, as many as you like. Long-time Vim users won't use menus much. But the power is in adding your own menus and menu items. They are most useful for things that you can't remember what the key sequence was. For creating menus in a different language, see |:menutrans|. *menu.vim* The default menus are read from the file "$VIMRUNTIME/menu.vim". See |$VIMRUNTIME| for where the path comes from. You can set up your own menus. Starting off with the default set is a good idea. You can add more items, or, if you don't like the defaults at all, start with removing all menus |:unmenu-all|. You can also avoid the default menus being loaded by adding this line to your .vimrc file (NOT your .gvimrc file!): :let did_install_default_menus = 1 If you also want to avoid the Syntax menu: :let did_install_syntax_menu = 1 If you do want the Syntax menu but not all the entries for each available syntax file (which take quite a bit of time to load): :let skip_syntax_sel_menu = 1 *console-menus* Although this documentation is in the GUI section, you can actually use menus in console mode too. You will have to load |menu.vim| explicitly then, it is not done by default. You can use the |:emenu| command and command-line completion with 'wildmenu' to access the menu entries almost like a real menu system. To do this, put these commands in your .vimrc file: :source $VIMRUNTIME/menu.vim :set wildmenu :set cpo-=< :set wcm=<C-Z> :map <F4> :emenu <C-Z> Pressing <F4> will start the menu. You can now use the cursor keys to select a menu entry. Hit <Enter> to execute it. Hit <Esc> if you want to cancel. This does require the |+menu| feature enabled at compile time. *tear-off-menus* GTK+ and Motif support Tear-off menus. These are sort of sticky menus or pop-up menus that are present all the time. If the resizing does not work correctly, this may be caused by using something like "Vim*geometry" in the defaults. Use "Vim.geometry" instead. The Win32 GUI version emulates Motif's tear-off menus. Actually, a Motif user will spot the differences easily, but hopefully they're just as useful. You can also use the |:tearoff| command together with |hidden-menus| to create floating menus that do not appear on the main menu bar. 5.2 Creating New Menus *creating-menus* *:me* *:menu* *:noreme* *:noremenu* *:am* *:amenu* *:an* *:anoremenu* *:nme* *:nmenu* *:nnoreme* *:nnoremenu* *:ome* *:omenu* *:onoreme* *:onoremenu* *:vme* *:vmenu* *:vnoreme* *:vnoremenu* *:xme* *:xmenu* *:xnoreme* *:xnoremenu* *:sme* *:smenu* *:snoreme* *:snoremenu* *:ime* *:imenu* *:inoreme* *:inoremenu* *:cme* *:cmenu* *:cnoreme* *:cnoremenu* *E330* *E327* *E331* *E336* *E333* *E328* *E329* *E337* *E792* To create a new menu item, use the ":menu" commands. They are mostly like the ":map" set of commands but the first argument is a menu item name, given as a path of menus and submenus with a '.' between them, e.g.: :menu File.Save :w<CR> :inoremenu File.Save <C-O>:w<CR> :menu Edit.Big\ Changes.Delete\ All\ Spaces :%s/[ ^I]//g<CR> This last one will create a new item in the menu bar called "Edit", holding the mouse button down on this will pop up a menu containing the item "Big Changes", which is a sub-menu containing the item "Delete All Spaces", which when selected, performs the operation. Special characters in a menu name: & The next character is the shortcut key. Make sure each shortcut key is only used once in a (sub)menu. If you want to insert a literal "&" in the menu name use "&&". <Tab> Separates the menu name from right-aligned text. This can be used to show the equivalent typed command. The text "<Tab>" can be used here for convenience. If you are using a real tab, don't forget to put a backslash before it! Example: :amenu &File.&Open<Tab>:e :browse e<CR> [typed literally] With the shortcut "F" (while keeping the <Alt> key pressed), and then "O", this menu can be used. The second part is shown as "Open :e". The ":e" is right aligned, and the "O" is underlined, to indicate it is the shortcut. The ":amenu" command can be used to define menu entries for all modes at once. To make the command work correctly, a character is automatically inserted for some modes: mode inserted appended Normal nothing nothing Visual <C-C> <C-\><C-G> Insert <C-O> Cmdline <C-C> <C-\><C-G> Op-pending <C-C> <C-\><C-G> Appending CTRL-\ CTRL-G is for going back to insert mode when 'insertmode' is set. |CTRL-\_CTRL-G| Example: :amenu File.Next :next^M is equal to: :nmenu File.Next :next^M :vmenu File.Next ^C:next^M^\^G :imenu File.Next ^O:next^M :cmenu File.Next ^C:next^M^\^G :omenu File.Next ^C:next^M^\^G Careful: In Insert mode this only works for a SINGLE Normal mode command, because of the CTRL-O. If you have two or more commands, you will need to use the ":imenu" command. For inserting text in any mode, you can use the expression register: :amenu Insert.foobar "='foobar'<CR>P Note that the '<' and 'k' flags in 'cpoptions' also apply here (when included they make the <> form and raw key codes not being recognized). Note that <Esc> in Cmdline mode executes the command, like in a mapping. This is Vi compatible. Use CTRL-C to quit Cmdline mode. *:menu-<silent>* *:menu-silent* To define a menu which will not be echoed on the command line, add "<silent>" as the first argument. Example: :menu <silent> Settings.Ignore\ case :set ic<CR> The ":set ic" will not be echoed when using this menu. Messages from the executed command are still given though. To shut them up too, add a ":silent" in the executed command: :menu <silent> Search.Header :exe ":silent normal /Header\r"<CR> "<silent>" may also appear just after "<special>" or "<script>". *:menu-<special>* *:menu-special* Define a menu with <> notation for special keys, even though the "<" flag may appear in 'cpoptions'. This is useful if the side effect of setting 'cpoptions' is not desired. Example: :menu <special> Search.Header /Header<CR> "<special>" must appear as the very first argument to the ":menu" command or just after "<silent>" or "<script>". *:menu-<script>* *:menu-script* The "to" part of the menu will be inspected for mappings. If you don't want this, use the ":noremenu" command (or the similar one for a specific mode). If you do want to use script-local mappings, add "<script>" as the very first argument to the ":menu" command or just after "<silent>" or "<special>". *menu-priority* You can give a priority to a menu. Menus with a higher priority go more to the right. The priority is given as a number before the ":menu" command. Example: :80menu Buffer.next :bn<CR> The default menus have these priorities: File 10 Edit 20 Tools 40 Syntax 50 Buffers 60 Window 70 Help 9999 When no or zero priority is given, 500 is used. The priority for the PopUp menu is not used. The Help menu will be placed on the far right side of the menu bar on systems which support this (Motif and GTK+). For GTK+ 2, this is not done anymore because right-aligning the Help menu is now discouraged UI design. You can use a priority higher than 9999, to make it go after the Help menu, but that is non-standard and is discouraged. The highest possible priority is about 32000. The lowest is 1. *sub-menu-priority* The same mechanism can be used to position a sub-menu. The priority is then given as a dot-separated list of priorities, before the menu name: :menu 80.500 Buffer.next :bn<CR> Giving the sub-menu priority is only needed when the item is not to be put in a normal position. For example, to put a sub-menu before the other items: :menu 80.100 Buffer.first :brew<CR> Or to put a sub-menu after the other items, and further items with default priority will be put before it: :menu 80.900 Buffer.last :blast<CR> When a number is missing, the default value 500 will be used: :menu .900 myMenu.test :echo "text"<CR> The menu priority is only used when creating a new menu. When it already existed, e.g., in another mode, the priority will not change. Thus, the priority only needs to be given the first time a menu is used. An exception is the PopUp menu. There is a separate menu for each mode (Normal, Op-pending, Visual, Insert, Cmdline). The order in each of these menus can be different. This is different from menu-bar menus, which have the same order for all modes. NOTE: sub-menu priorities currently don't work for all versions of the GUI. *menu-separator* *E332* Menu items can be separated by a special item that inserts some space between items. Depending on the system this is displayed as a line or a dotted line. These items must start with a '-' and end in a '-'. The part in between is used to give it a unique name. Priorities can be used as with normal items. Example: :menu Example.item1 :do something :menu Example.-Sep- : :menu Example.item2 :do something different Note that the separator also requires a rhs. It doesn't matter what it is, because the item will never be selected. Use a single colon to keep it simple. *gui-toolbar* The toolbar is currently available in the Win32, Athena, Motif, GTK+ (X11), and Photon GUI. It should turn up in other GUIs in due course. The default toolbar is setup in menu.vim. The display of the toolbar is controlled by the 'guioptions' letter 'T'. You can thus have menu & toolbar together, or either on its own, or neither. The appearance is controlled by the 'toolbar' option. You can chose between an image, text or both. *toolbar-icon* The toolbar is defined as a special menu called ToolBar, which only has one level. Vim interprets the items in this menu as follows: 1) If an "icon=" argument was specified, the file with this name is used. The file can either be specified with the full path or with the base name. In the last case it is searched for in the "bitmaps" directory in 'runtimepath', like in point 3. Examples: :amenu icon=/usr/local/pixmaps/foo_icon.xpm ToolBar.Foo :echo "Foo"<CR> :amenu icon=FooIcon ToolBar.Foo :echo "Foo"<CR> Note that in the first case the extension is included, while in the second case it is omitted. If the file cannot be opened the next points are tried. A space in the file name must be escaped with a backslash. A menu priority must come _after_ the icon argument: :amenu icon=foo 1.42 ToolBar.Foo :echo "42!"<CR> 2) An item called 'BuiltIn##', where ## is a number, is taken as number ## of the built-in bitmaps available in Vim. Currently there are 31 numbered from 0 to 30 which cover most common editing operations |builtin-tools|. :amenu ToolBar.BuiltIn22 :call SearchNext("back")<CR> 3) An item with another name is first searched for in the directory "bitmaps" in 'runtimepath'. If found, the bitmap file is used as the toolbar button image. Note that the exact filename is OS-specific: For example, under Win32 the command :amenu ToolBar.Hello :echo "hello"<CR> would find the file 'hello.bmp'. Under GTK+/X11 it is 'Hello.xpm'. With GTK+ 2 the files 'Hello.png', 'Hello.xpm' and 'Hello.bmp' are checked for existence, and the first one found would be used. For MS-Windows and GTK+ 2 the bitmap is scaled to fit the button. For MS-Windows a size of 18 by 18 pixels works best. For MS-Windows the bitmap should have 16 colors with the standard palette. The light grey pixels will be changed to the Window frame color and the dark grey pixels to the window shadow color. More colors might also work, depending on your system. 4) If the bitmap is still not found, Vim checks for a match against its list of built-in names. Each built-in button image has a name. So the command :amenu ToolBar.Open :e will show the built-in "open a file" button image if no open.bmp exists. All the built-in names can be seen used in menu.vim. 5) If all else fails, a blank, but functioning, button is displayed. *builtin-tools* nr Name Normal action 00 New open new window 01 Open browse for file to open in current window 02 Save write buffer to file 03 Undo undo last change 04 Redo redo last undone change 05 Cut delete selected text to clipboard 06 Copy copy selected text to clipboard 07 Paste paste text from clipboard 08 Print print current buffer 09 Help open a buffer on Vim's builtin help 10 Find start a search command 11 SaveAll write all modified buffers to file 12 SaveSesn write session file for current situation 13 NewSesn write new session file 14 LoadSesn load session file 15 RunScript browse for file to run as a Vim script 16 Replace prompt for substitute command 17 WinClose close current window 18 WinMax make current window use many lines 19 WinMin make current window use few lines 20 WinSplit split current window 21 Shell start a shell 22 FindPrev search again, backward 23 FindNext search again, forward 24 FindHelp prompt for word to search help for 25 Make run make and jump to first error 26 TagJump jump to tag under the cursor 27 RunCtags build tags for files in current directory 28 WinVSplit split current window vertically 29 WinMaxWidth make current window use many columns 30 WinMinWidth make current window use few columns *hidden-menus* *win32-hidden-menus* In the Win32 and GTK+ GUI, starting a menu name with ']' excludes that menu from the main menu bar. You must then use the |:popup| or |:tearoff| command to display it. *popup-menu* In the Win32, GTK+, Motif, Athena and Photon GUI, you can define the special menu "PopUp". This is the menu that is displayed when the right mouse button is pressed, if 'mousemodel' is set to popup or popup_setpos. 5.3 Showing What Menus Are Mapped To *showing-menus* To see what an existing menu is mapped to, use just one argument after the menu commands (just like you would with the ":map" commands). If the menu specified is a submenu, then all menus under that hierarchy will be shown. If no argument is given after :menu at all, then ALL menu items are shown for the appropriate mode (e.g., Command-line mode for :cmenu). Special characters in the list, just before the rhs: * The menu was defined with "nore" to disallow remapping. & The menu was defined with "<script>" to allow remapping script-local mappings only. - The menu was disabled. Note that hitting <Tab> while entering a menu name after a menu command may be used to complete the name of the menu item. 5.4 Executing Menus *execute-menus* *:em* *:emenu* *E334* *E335* :[range]em[enu] {menu} Execute {menu} from the command line. The default is to execute the Normal mode menu. If a range is specified, it executes the Visual mode menu. If used from <c-o>, it executes the insert-mode menu Eg: :emenu File.Exit If the console-mode vim has been compiled with WANT_MENU defined, you can use :emenu to access useful menu items you may have got used to from GUI mode. See 'wildmenu' for an option that works well with this. See |console-menus| for an example. When using a range, if the lines match with '<,'>, then the menu is executed using the last visual selection. 5.5 Deleting Menus *delete-menus* *:unme* *:unmenu* *:aun* *:aunmenu* *:nunme* *:nunmenu* *:ounme* *:ounmenu* *:vunme* *:vunmenu* *:xunme* *:xunmenu* *:sunme* *:sunmenu* *:iunme* *:iunmenu* *:cunme* *:cunmenu* To delete a menu item or a whole submenu, use the unmenu commands, which are analogous to the unmap commands. Eg: :unmenu! Edit.Paste This will remove the Paste item from the Edit menu for Insert and Command-line modes. Note that hitting <Tab> while entering a menu name after an umenu command may be used to complete the name of the menu item for the appropriate mode. To remove all menus use: *:unmenu-all* :unmenu * " remove all menus in Normal and visual mode :unmenu! * " remove all menus in Insert and Command-line mode :aunmenu * " remove all menus in all modes If you want to get rid of the menu bar: :set guioptions-=m 5.6 Disabling Menus *disable-menus* *:menu-disable* *:menu-enable* If you do not want to remove a menu, but disable it for a moment, this can be done by adding the "enable" or "disable" keyword to a ":menu" command. Examples: :menu disable &File.&Open\.\.\. :amenu enable * :amenu disable &Tools.* The command applies to the modes as used with all menu commands. Note that characters like "&" need to be included for translated names to be found. When the argument is "*", all menus are affected. Otherwise the given menu name and all existing submenus below it are affected. 5.7 Examples for Menus *menu-examples* Here is an example on how to add menu items with menu's! You can add a menu item for the keyword under the cursor. The register "z" is used. :nmenu Words.Add\ Var wb"zye:menu! Words.<C-R>z <C-R>z<CR> :nmenu Words.Remove\ Var wb"zye:unmenu! Words.<C-R>z<CR> :vmenu Words.Add\ Var "zy:menu! Words.<C-R>z <C-R>z <CR> :vmenu Words.Remove\ Var "zy:unmenu! Words.<C-R>z<CR> :imenu Words.Add\ Var <Esc>wb"zye:menu! Words.<C-R>z <C-R>z<CR>a :imenu Words.Remove\ Var <Esc>wb"zye:unmenu! Words.<C-R>z<CR>a (the rhs is in <> notation, you can copy/paste this text to try out the mappings, or put these lines in your gvimrc; "<C-R>" is CTRL-R, "<CR>" is the <CR> key. |<>|) 5.8 Tooltips & Menu tips See section |42.4| in the user manual. *:tmenu* *:tm* :tm[enu] {menupath} {rhs} Define a tip for a menu or tool. {only in X11 and Win32 GUI} :tm[enu] [menupath] List menu tips. {only in X11 and Win32 GUI} *:tunmenu* *:tu* :tu[nmenu] {menupath} Remove a tip for a menu or tool. {only in X11 and Win32 GUI} When a tip is defined for a menu item, it appears in the command-line area when the mouse is over that item, much like a standard Windows menu hint in the status bar. (Except when Vim is in Command-line mode, when of course nothing is displayed.) When a tip is defined for a ToolBar item, it appears as a tooltip when the mouse pauses over that button, in the usual fashion. Use the |hl-Tooltip| highlight group to change its colors. A "tip" can be defined for each menu item. For example, when defining a menu item like this: :amenu MyMenu.Hello :echo "Hello"<CR> The tip is defined like this: :tmenu MyMenu.Hello Displays a greeting. And delete it with: :tunmenu MyMenu.Hello Tooltips are currently only supported for the X11 and Win32 GUI. However, they should appear for the other gui platforms in the not too distant future. The ":tmenu" command works just like other menu commands, it uses the same arguments. ":tunmenu" deletes an existing menu tip, in the same way as the other unmenu commands. If a menu item becomes invalid (i.e. its actions in all modes are deleted) Vim deletes the menu tip (and the item) for you. This means that :aunmenu deletes a menu item - you don't need to do a :tunmenu as well. 5.9 Popup Menus In the Win32 and GTK+ GUI, you can cause a menu to popup at the cursor. This behaves similarly to the PopUp menus except that any menu tree can be popped up. This command is for backwards compatibility, using it is discouraged, because it behaves in a strange way. *:popup* *:popu* :popu[p] {name} Popup the menu {name}. The menu named must have at least one subentry, but need not appear on the menu-bar (see |hidden-menus|). {only available for Win32 and GTK GUI} :popu[p]! {name} Like above, but use the position of the mouse pointer instead of the cursor. Example: :popup File will make the "File" menu (if there is one) appear at the text cursor (mouse pointer if ! was used). :amenu ]Toolbar.Make :make<CR> :popup ]Toolbar This creates a popup menu that doesn't exist on the main menu-bar. Note that a menu that starts with ']' will not be displayed.
6. Extras *gui-extras* This section describes other features which are related to the GUI. - With the GUI, there is no wait for one second after hitting escape, because the key codes don't start with <Esc>. - Typing ^V followed by a special key in the GUI will insert "<Key>", since the internal string used is meaningless. Modifiers may also be held down to get "<Modifiers-Key>". - In the GUI, the modifiers SHIFT, CTRL, and ALT (or META) may be used within mappings of special keys and mouse events. E.g.: :map <M-LeftDrag> <LeftDrag> - In the GUI, several normal keys may have modifiers in mappings etc, these are <Space>, <Tab>, <NL>, <CR>, <Esc>. - To check in a Vim script if the GUI is being used, you can use something like this: if has("gui_running") echo "yes, we have a GUI" else echo "Boring old console" endif *setting-guifont* - When you use the same vimrc file on various systems, you can use something like this to set options specifically for each type of GUI: if has("gui_running") if has("gui_gtk2") :set guifont=Luxi\ Mono\ 12 elseif has("x11") " Also for GTK 1 :set guifont=*-lucidatypewriter-medium-r-normal-*-*-180-*-*-m-*-* elseif has("gui_win32") :set guifont=Luxi_Mono:h12:cANSI endif endif A recommended Japanese font is MS Mincho. You can find info here: http://www.lexikan.com/mincho.htm
7. Shell Commands *gui-shell* For the X11 GUI the external commands are executed inside the gvim window. See |gui-pty|. WARNING: Executing an external command from the X11 GUI will not always work. "normal" commands like "ls", "grep" and "make" mostly work fine. Commands that require an intelligent terminal like "less" and "ispell" won't work. Some may even hang and need to be killed from another terminal. So be careful! For the Win32 GUI the external commands are executed in a separate window. See |gui-shell-win32|. top - main help file


Reports when getClass() method is called on java.lang.Class instance. This is usually a mistake as the result is
always equivalent to Class.class. If it's mistake then the getClass() call should be removed and qualifier should be used
directly. If the behavior is intended, then it's better to write Class.class explicitly to avoid confusion.
New in 2018.2


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/equality.20of.20proofs.html ---
Is this lemma true and what is it (or should it be) called?
lemma hpropext {p q : Prop} (a : p) (b : q) : a == b := sorry
proof_irrel
is the non-heterogeneous version
OK, I managed to prove it
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


| PostgreSQL 9.0.10 Documentation | ||||
|---|---|---|---|---|
| Prev | Up | Chapter 12. Full Text Search | Next |
Applications that used the contrib/tsearch2 add-on module for text searching will need some adjustments to work with the built-in features:
Some functions have been renamed or had small adjustments in their argument lists, and all of them are now in the pg_catalog schema, whereas in a previous installation they would have been in public or another non-system schema. There is a new version of contrib/tsearch2 (see Section F.38) that provides a compatibility layer to solve most problems in this area.
The old contrib/tsearch2 functions and other objects must be suppressed when loading pg_dump output from a pre-8.3 database. While many of them won't load anyway, a few will and then cause problems. One simple way to deal with this is to load the new contrib/tsearch2 module before restoring the dump; then it will block the old objects from being loaded.
Text search configuration setup is completely different now. Instead of manually inserting rows into configuration tables, search is configured through the specialized SQL commands shown earlier in this chapter. There is no automated support for converting an existing custom configuration for 8.3; you're on your own here.
Most types of dictionaries rely on some outside-the-database configuration files. These are largely compatible with pre-8.3 usage, but note the following differences:
Configuration files now must be placed in a single specified directory ($SHAREDIR/tsearch_data), and must have a specific extension depending on the type of file, as noted previously in the descriptions of the various dictionary types. This restriction was added to forestall security problems.
Configuration files must be encoded in UTF-8 encoding, regardless of what database encoding is used.
In thesaurus configuration files, stop words must be marked with ?.


Home
Teams
Community
AboutUs
My Profile
Logout
create your TEAM!
Hello Matchers
Join
Leave
Update
Delete
join chat!
Join
Leave Team
Update
Delete
join chat!


Wendler 5/3/1
Input
Week 1
Week 2
Week 3
Username
Start date
Bench Press
Military Press
Squat
Deadlift
Front Squat
Stiff Leg Deadlift
Close Grip Bench Press
Incline Press
Save
Week 1
Exercise
Set 1
Set 2
Set 3
Week 2
Exercise
Set 1
Set 2
Set 3
Week 3
Exercise
Set 1
Set 2
Set 3


{%extends "basedialog.html"%} {%import "commonExecuteCallback.js" as commons%} {%block title %}Welcome to pixiedust learning{%endblock%} {%block body%}


data land-use climate emissions land used SSP Table model Global mitigation scenarios AIM-SSP/RCP gridded {border-style px;} #ffffff;} Change ScenarioMIP data. global Environmental AIM/CGE Model base carbon use . Wm change scenario CEDS Figure energy grid socioeconomic using year ./j.gloenvcha... AIM Data Fujimori Supplementary aggregated file SSPs based datasets different future models crop forcing forest Climate Energy GDP Hasegawa available emission emissions, information levels provided px; total urban {font-family Baseline Fig. IAM Shared Socioeconomic cropland data, dataset density example, font-size include range regional regions represented CMIP International Land Masui Project RCPs assessment cells classifications differ differences double; downscaled emissions. generated included level main matrix population regionally research similar (Data (i.e. Citation Commons Creative First, Ito LUH National NetCDF addition, agricultural allocation analysis area border-color border-width calculated century costs described development environmental high map modelling original populations production sector shown single solid; spatially stored values {font-style {font-weight (e.g. AIM/PLUM Agriculture Building CEDS. Emissions GHG Gridded Group IAV Industry Intercomparison Japan Land-use Pathways Population Ratio Rest Takahashi according afforestation applied areas assumption biodiversity bioenergy bold case characteristics compared concentration considered convention courier; cover discrepancies em; gas however, human including integrated irrigation level. mainly managed method naming obtain outcomes overview performed possible productivity provide pt;} ratio relevant scales. simulation small spatial stock transport unit use, uses value van world yield yields