id
int32 0
24.9k
| repo
stringlengths 5
58
| path
stringlengths 9
168
| func_name
stringlengths 9
130
| original_string
stringlengths 66
10.5k
| language
stringclasses 1
value | code
stringlengths 66
10.5k
| code_tokens
list | docstring
stringlengths 8
16k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 94
266
|
|---|---|---|---|---|---|---|---|---|---|---|---|
19,000
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.after_initialize
|
def after_initialize
@comments ||= {}
@associations = {}
@definitions = initial_definitions
@constant_loader = ConstantLoader.new(:definitions => @definitions)
@scopes = [@definitions]
@value_stack = NestedStack.new
@variable_stack = NestedStack.new
@ignored_nodes = []
@visibility = :public
reset_docstring_tags
reset_method_type
@constant_loader.bootstrap
end
|
ruby
|
def after_initialize
@comments ||= {}
@associations = {}
@definitions = initial_definitions
@constant_loader = ConstantLoader.new(:definitions => @definitions)
@scopes = [@definitions]
@value_stack = NestedStack.new
@variable_stack = NestedStack.new
@ignored_nodes = []
@visibility = :public
reset_docstring_tags
reset_method_type
@constant_loader.bootstrap
end
|
[
"def",
"after_initialize",
"@comments",
"||=",
"{",
"}",
"@associations",
"=",
"{",
"}",
"@definitions",
"=",
"initial_definitions",
"@constant_loader",
"=",
"ConstantLoader",
".",
"new",
"(",
":definitions",
"=>",
"@definitions",
")",
"@scopes",
"=",
"[",
"@definitions",
"]",
"@value_stack",
"=",
"NestedStack",
".",
"new",
"@variable_stack",
"=",
"NestedStack",
".",
"new",
"@ignored_nodes",
"=",
"[",
"]",
"@visibility",
"=",
":public",
"reset_docstring_tags",
"reset_method_type",
"@constant_loader",
".",
"bootstrap",
"end"
] |
Called after a new instance of the virtual machine has been created.
|
[
"Called",
"after",
"a",
"new",
"instance",
"of",
"the",
"virtual",
"machine",
"has",
"been",
"created",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L165-L181
|
19,001
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.run
|
def run(ast)
ast = [ast] unless ast.is_a?(Array)
# pre-load all the built-in definitions.
@constant_loader.run(ast)
ast.each { |node| iterate(node) }
freeze
end
|
ruby
|
def run(ast)
ast = [ast] unless ast.is_a?(Array)
# pre-load all the built-in definitions.
@constant_loader.run(ast)
ast.each { |node| iterate(node) }
freeze
end
|
[
"def",
"run",
"(",
"ast",
")",
"ast",
"=",
"[",
"ast",
"]",
"unless",
"ast",
".",
"is_a?",
"(",
"Array",
")",
"# pre-load all the built-in definitions.",
"@constant_loader",
".",
"run",
"(",
"ast",
")",
"ast",
".",
"each",
"{",
"|",
"node",
"|",
"iterate",
"(",
"node",
")",
"}",
"freeze",
"end"
] |
Processes the given AST or a collection of AST nodes.
@see #iterate
@param [Array|RubyLint::AST::Node] ast
|
[
"Processes",
"the",
"given",
"AST",
"or",
"a",
"collection",
"of",
"AST",
"nodes",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L189-L198
|
19,002
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.after_or_asgn
|
def after_or_asgn
variable = variable_stack.pop.first
value = value_stack.pop.first
if variable and value
conditional_assignment(variable, value, false)
end
end
|
ruby
|
def after_or_asgn
variable = variable_stack.pop.first
value = value_stack.pop.first
if variable and value
conditional_assignment(variable, value, false)
end
end
|
[
"def",
"after_or_asgn",
"variable",
"=",
"variable_stack",
".",
"pop",
".",
"first",
"value",
"=",
"value_stack",
".",
"pop",
".",
"first",
"if",
"variable",
"and",
"value",
"conditional_assignment",
"(",
"variable",
",",
"value",
",",
"false",
")",
"end",
"end"
] |
Processes an `or` assignment in the form of `variable ||= value`.
|
[
"Processes",
"an",
"or",
"assignment",
"in",
"the",
"form",
"of",
"variable",
"||",
"=",
"value",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L311-L318
|
19,003
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.after_and_asgn
|
def after_and_asgn
variable = variable_stack.pop.first
value = value_stack.pop.first
conditional_assignment(variable, value)
end
|
ruby
|
def after_and_asgn
variable = variable_stack.pop.first
value = value_stack.pop.first
conditional_assignment(variable, value)
end
|
[
"def",
"after_and_asgn",
"variable",
"=",
"variable_stack",
".",
"pop",
".",
"first",
"value",
"=",
"value_stack",
".",
"pop",
".",
"first",
"conditional_assignment",
"(",
"variable",
",",
"value",
")",
"end"
] |
Processes an `and` assignment in the form of `variable &&= value`.
|
[
"Processes",
"an",
"and",
"assignment",
"in",
"the",
"form",
"of",
"variable",
"&&",
"=",
"value",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L327-L332
|
19,004
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.after_array
|
def after_array(node)
builder = DefinitionBuilder::RubyArray.new(
node,
self,
:values => value_stack.pop
)
push_value(builder.build)
end
|
ruby
|
def after_array(node)
builder = DefinitionBuilder::RubyArray.new(
node,
self,
:values => value_stack.pop
)
push_value(builder.build)
end
|
[
"def",
"after_array",
"(",
"node",
")",
"builder",
"=",
"DefinitionBuilder",
"::",
"RubyArray",
".",
"new",
"(",
"node",
",",
"self",
",",
":values",
"=>",
"value_stack",
".",
"pop",
")",
"push_value",
"(",
"builder",
".",
"build",
")",
"end"
] |
Builds an Array.
@param [RubyLint::AST::Node] node
|
[
"Builds",
"an",
"Array",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L387-L395
|
19,005
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.after_hash
|
def after_hash(node)
builder = DefinitionBuilder::RubyHash.new(
node,
self,
:values => value_stack.pop
)
push_value(builder.build)
end
|
ruby
|
def after_hash(node)
builder = DefinitionBuilder::RubyHash.new(
node,
self,
:values => value_stack.pop
)
push_value(builder.build)
end
|
[
"def",
"after_hash",
"(",
"node",
")",
"builder",
"=",
"DefinitionBuilder",
"::",
"RubyHash",
".",
"new",
"(",
"node",
",",
"self",
",",
":values",
"=>",
"value_stack",
".",
"pop",
")",
"push_value",
"(",
"builder",
".",
"build",
")",
"end"
] |
Builds a Hash.
@param [RubyLint::AST::Node] node
|
[
"Builds",
"a",
"Hash",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L409-L417
|
19,006
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.on_self
|
def on_self
scope = current_scope
method = scope.lookup(scope.method_call_type, 'self')
push_value(method.return_value)
end
|
ruby
|
def on_self
scope = current_scope
method = scope.lookup(scope.method_call_type, 'self')
push_value(method.return_value)
end
|
[
"def",
"on_self",
"scope",
"=",
"current_scope",
"method",
"=",
"scope",
".",
"lookup",
"(",
"scope",
".",
"method_call_type",
",",
"'self'",
")",
"push_value",
"(",
"method",
".",
"return_value",
")",
"end"
] |
Pushes the value of `self` onto the current stack.
|
[
"Pushes",
"the",
"value",
"of",
"self",
"onto",
"the",
"current",
"stack",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L446-L451
|
19,007
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.on_class
|
def on_class(node)
parent = nil
parent_node = node.children[1]
if parent_node
parent = evaluate_node(parent_node)
if !parent or !parent.const?
# FIXME: this should use `definitions` instead.
parent = current_scope.lookup(:const, 'Object')
end
end
define_module(node, DefinitionBuilder::RubyClass, :parent => parent)
end
|
ruby
|
def on_class(node)
parent = nil
parent_node = node.children[1]
if parent_node
parent = evaluate_node(parent_node)
if !parent or !parent.const?
# FIXME: this should use `definitions` instead.
parent = current_scope.lookup(:const, 'Object')
end
end
define_module(node, DefinitionBuilder::RubyClass, :parent => parent)
end
|
[
"def",
"on_class",
"(",
"node",
")",
"parent",
"=",
"nil",
"parent_node",
"=",
"node",
".",
"children",
"[",
"1",
"]",
"if",
"parent_node",
"parent",
"=",
"evaluate_node",
"(",
"parent_node",
")",
"if",
"!",
"parent",
"or",
"!",
"parent",
".",
"const?",
"# FIXME: this should use `definitions` instead.",
"parent",
"=",
"current_scope",
".",
"lookup",
"(",
":const",
",",
"'Object'",
")",
"end",
"end",
"define_module",
"(",
"node",
",",
"DefinitionBuilder",
"::",
"RubyClass",
",",
":parent",
"=>",
"parent",
")",
"end"
] |
Creates the definition for a class.
@param [RubyLint::AST::Node] node
|
[
"Creates",
"the",
"definition",
"for",
"a",
"class",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L481-L495
|
19,008
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.on_block
|
def on_block(node)
builder = DefinitionBuilder::RubyBlock.new(node, self)
definition = builder.build
associate_node(node, definition)
push_scope(definition)
end
|
ruby
|
def on_block(node)
builder = DefinitionBuilder::RubyBlock.new(node, self)
definition = builder.build
associate_node(node, definition)
push_scope(definition)
end
|
[
"def",
"on_block",
"(",
"node",
")",
"builder",
"=",
"DefinitionBuilder",
"::",
"RubyBlock",
".",
"new",
"(",
"node",
",",
"self",
")",
"definition",
"=",
"builder",
".",
"build",
"associate_node",
"(",
"node",
",",
"definition",
")",
"push_scope",
"(",
"definition",
")",
"end"
] |
Builds the definition for a block.
@param [RubyLint::AST::Node] node
|
[
"Builds",
"the",
"definition",
"for",
"a",
"block",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L509-L516
|
19,009
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.on_def
|
def on_def(node)
receiver = nil
if node.type == :defs
receiver = evaluate_node(node.children[0])
end
builder = DefinitionBuilder::RubyMethod.new(
node,
self,
:type => @method_type,
:receiver => receiver,
:visibility => @visibility
)
definition = builder.build
builder.scope.add_definition(definition)
associate_node(node, definition)
buffer_docstring_tags(node)
if docstring_tags and docstring_tags.return_tag
assign_return_value_from_tag(
docstring_tags.return_tag,
definition
)
end
push_scope(definition)
end
|
ruby
|
def on_def(node)
receiver = nil
if node.type == :defs
receiver = evaluate_node(node.children[0])
end
builder = DefinitionBuilder::RubyMethod.new(
node,
self,
:type => @method_type,
:receiver => receiver,
:visibility => @visibility
)
definition = builder.build
builder.scope.add_definition(definition)
associate_node(node, definition)
buffer_docstring_tags(node)
if docstring_tags and docstring_tags.return_tag
assign_return_value_from_tag(
docstring_tags.return_tag,
definition
)
end
push_scope(definition)
end
|
[
"def",
"on_def",
"(",
"node",
")",
"receiver",
"=",
"nil",
"if",
"node",
".",
"type",
"==",
":defs",
"receiver",
"=",
"evaluate_node",
"(",
"node",
".",
"children",
"[",
"0",
"]",
")",
"end",
"builder",
"=",
"DefinitionBuilder",
"::",
"RubyMethod",
".",
"new",
"(",
"node",
",",
"self",
",",
":type",
"=>",
"@method_type",
",",
":receiver",
"=>",
"receiver",
",",
":visibility",
"=>",
"@visibility",
")",
"definition",
"=",
"builder",
".",
"build",
"builder",
".",
"scope",
".",
"add_definition",
"(",
"definition",
")",
"associate_node",
"(",
"node",
",",
"definition",
")",
"buffer_docstring_tags",
"(",
"node",
")",
"if",
"docstring_tags",
"and",
"docstring_tags",
".",
"return_tag",
"assign_return_value_from_tag",
"(",
"docstring_tags",
".",
"return_tag",
",",
"definition",
")",
"end",
"push_scope",
"(",
"definition",
")",
"end"
] |
Creates the definition for a method definition.
@param [RubyLint::AST::Node] node
|
[
"Creates",
"the",
"definition",
"for",
"a",
"method",
"definition",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L558-L589
|
19,010
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.after_def
|
def after_def
previous = pop_scope
current = current_scope
reset_docstring_tags
EXPORT_VARIABLES.each do |type|
current.copy(previous, type)
end
end
|
ruby
|
def after_def
previous = pop_scope
current = current_scope
reset_docstring_tags
EXPORT_VARIABLES.each do |type|
current.copy(previous, type)
end
end
|
[
"def",
"after_def",
"previous",
"=",
"pop_scope",
"current",
"=",
"current_scope",
"reset_docstring_tags",
"EXPORT_VARIABLES",
".",
"each",
"do",
"|",
"type",
"|",
"current",
".",
"copy",
"(",
"previous",
",",
"type",
")",
"end",
"end"
] |
Exports various variables to the outer scope of the method definition.
|
[
"Exports",
"various",
"variables",
"to",
"the",
"outer",
"scope",
"of",
"the",
"method",
"definition",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L594-L603
|
19,011
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.on_send
|
def on_send(node)
name = node.children[1].to_s
name = SEND_MAPPING.fetch(name, name)
callback = "on_send_#{name}"
value_stack.add_stack
execute_callback(callback, node)
end
|
ruby
|
def on_send(node)
name = node.children[1].to_s
name = SEND_MAPPING.fetch(name, name)
callback = "on_send_#{name}"
value_stack.add_stack
execute_callback(callback, node)
end
|
[
"def",
"on_send",
"(",
"node",
")",
"name",
"=",
"node",
".",
"children",
"[",
"1",
"]",
".",
"to_s",
"name",
"=",
"SEND_MAPPING",
".",
"fetch",
"(",
"name",
",",
"name",
")",
"callback",
"=",
"\"on_send_#{name}\"",
"value_stack",
".",
"add_stack",
"execute_callback",
"(",
"callback",
",",
"node",
")",
"end"
] |
Processes a method call. If a certain method call has its own dedicated
callback that one will be called as well.
@param [RubyLint::AST::Node] node
|
[
"Processes",
"a",
"method",
"call",
".",
"If",
"a",
"certain",
"method",
"call",
"has",
"its",
"own",
"dedicated",
"callback",
"that",
"one",
"will",
"be",
"called",
"as",
"well",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L640-L648
|
19,012
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.initial_definitions
|
def initial_definitions
definitions = Definition::RubyObject.new(
:name => 'root',
:type => :root,
:instance_type => :instance,
:inherit_self => false
)
definitions.parents = [
definitions.constant_proxy('Object', RubyLint.registry)
]
definitions.define_self
return definitions
end
|
ruby
|
def initial_definitions
definitions = Definition::RubyObject.new(
:name => 'root',
:type => :root,
:instance_type => :instance,
:inherit_self => false
)
definitions.parents = [
definitions.constant_proxy('Object', RubyLint.registry)
]
definitions.define_self
return definitions
end
|
[
"def",
"initial_definitions",
"definitions",
"=",
"Definition",
"::",
"RubyObject",
".",
"new",
"(",
":name",
"=>",
"'root'",
",",
":type",
"=>",
":root",
",",
":instance_type",
"=>",
":instance",
",",
":inherit_self",
"=>",
"false",
")",
"definitions",
".",
"parents",
"=",
"[",
"definitions",
".",
"constant_proxy",
"(",
"'Object'",
",",
"RubyLint",
".",
"registry",
")",
"]",
"definitions",
".",
"define_self",
"return",
"definitions",
"end"
] |
Returns the initial set of definitions to use.
@return [RubyLint::Definition::RubyObject]
|
[
"Returns",
"the",
"initial",
"set",
"of",
"definitions",
"to",
"use",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L810-L825
|
19,013
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.push_scope
|
def push_scope(definition)
unless definition.is_a?(RubyLint::Definition::RubyObject)
raise(
ArgumentError,
"Expected a RubyLint::Definition::RubyObject but got " \
"#{definition.class} instead"
)
end
@scopes << definition
end
|
ruby
|
def push_scope(definition)
unless definition.is_a?(RubyLint::Definition::RubyObject)
raise(
ArgumentError,
"Expected a RubyLint::Definition::RubyObject but got " \
"#{definition.class} instead"
)
end
@scopes << definition
end
|
[
"def",
"push_scope",
"(",
"definition",
")",
"unless",
"definition",
".",
"is_a?",
"(",
"RubyLint",
"::",
"Definition",
"::",
"RubyObject",
")",
"raise",
"(",
"ArgumentError",
",",
"\"Expected a RubyLint::Definition::RubyObject but got \"",
"\"#{definition.class} instead\"",
")",
"end",
"@scopes",
"<<",
"definition",
"end"
] |
Pushes a new scope on the list of available scopes.
@param [RubyLint::Definition::RubyObject] definition
|
[
"Pushes",
"a",
"new",
"scope",
"on",
"the",
"list",
"of",
"available",
"scopes",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L870-L880
|
19,014
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.push_variable_value
|
def push_variable_value(node)
return if value_stack.empty? || @ignored_nodes.include?(node)
definition = definition_for_node(node)
if definition
value = definition.value ? definition.value : definition
push_value(value)
end
end
|
ruby
|
def push_variable_value(node)
return if value_stack.empty? || @ignored_nodes.include?(node)
definition = definition_for_node(node)
if definition
value = definition.value ? definition.value : definition
push_value(value)
end
end
|
[
"def",
"push_variable_value",
"(",
"node",
")",
"return",
"if",
"value_stack",
".",
"empty?",
"||",
"@ignored_nodes",
".",
"include?",
"(",
"node",
")",
"definition",
"=",
"definition_for_node",
"(",
"node",
")",
"if",
"definition",
"value",
"=",
"definition",
".",
"value",
"?",
"definition",
".",
"value",
":",
"definition",
"push_value",
"(",
"value",
")",
"end",
"end"
] |
Pushes the value of a variable onto the value stack.
@param [RubyLint::AST::Node] node
|
[
"Pushes",
"the",
"value",
"of",
"a",
"variable",
"onto",
"the",
"value",
"stack",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L896-L906
|
19,015
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.assign_variable
|
def assign_variable(type, name, value, node)
scope = assignment_scope(type)
variable = scope.lookup(type, name)
# If there's already a variable we'll just update it.
if variable
variable.reference_amount += 1
# `value` is not for conditional assignments as those are handled
# manually.
variable.value = value if value
else
variable = Definition::RubyObject.new(
:type => type,
:name => name,
:value => value,
:instance_type => :instance,
:reference_amount => 0,
:line => node.line,
:column => node.column,
:file => node.file
)
end
buffer_assignment_value(value)
# Primarily used by #after_send to support variable assignments as method
# call arguments.
if value and !value_stack.empty?
value_stack.push(variable.value)
end
add_variable(variable, scope)
end
|
ruby
|
def assign_variable(type, name, value, node)
scope = assignment_scope(type)
variable = scope.lookup(type, name)
# If there's already a variable we'll just update it.
if variable
variable.reference_amount += 1
# `value` is not for conditional assignments as those are handled
# manually.
variable.value = value if value
else
variable = Definition::RubyObject.new(
:type => type,
:name => name,
:value => value,
:instance_type => :instance,
:reference_amount => 0,
:line => node.line,
:column => node.column,
:file => node.file
)
end
buffer_assignment_value(value)
# Primarily used by #after_send to support variable assignments as method
# call arguments.
if value and !value_stack.empty?
value_stack.push(variable.value)
end
add_variable(variable, scope)
end
|
[
"def",
"assign_variable",
"(",
"type",
",",
"name",
",",
"value",
",",
"node",
")",
"scope",
"=",
"assignment_scope",
"(",
"type",
")",
"variable",
"=",
"scope",
".",
"lookup",
"(",
"type",
",",
"name",
")",
"# If there's already a variable we'll just update it.",
"if",
"variable",
"variable",
".",
"reference_amount",
"+=",
"1",
"# `value` is not for conditional assignments as those are handled",
"# manually.",
"variable",
".",
"value",
"=",
"value",
"if",
"value",
"else",
"variable",
"=",
"Definition",
"::",
"RubyObject",
".",
"new",
"(",
":type",
"=>",
"type",
",",
":name",
"=>",
"name",
",",
":value",
"=>",
"value",
",",
":instance_type",
"=>",
":instance",
",",
":reference_amount",
"=>",
"0",
",",
":line",
"=>",
"node",
".",
"line",
",",
":column",
"=>",
"node",
".",
"column",
",",
":file",
"=>",
"node",
".",
"file",
")",
"end",
"buffer_assignment_value",
"(",
"value",
")",
"# Primarily used by #after_send to support variable assignments as method",
"# call arguments.",
"if",
"value",
"and",
"!",
"value_stack",
".",
"empty?",
"value_stack",
".",
"push",
"(",
"variable",
".",
"value",
")",
"end",
"add_variable",
"(",
"variable",
",",
"scope",
")",
"end"
] |
Assigns a basic variable.
@param [Symbol] type The type of variable.
@param [String] name The name of the variable
@param [RubyLint::Definition::RubyObject] value
@param [RubyLint::AST::Node] node
|
[
"Assigns",
"a",
"basic",
"variable",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L940-L973
|
19,016
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.add_variable
|
def add_variable(variable, scope = current_scope)
if variable_stack.empty?
scope.add(variable.type, variable.name, variable)
else
variable_stack.push(variable)
end
end
|
ruby
|
def add_variable(variable, scope = current_scope)
if variable_stack.empty?
scope.add(variable.type, variable.name, variable)
else
variable_stack.push(variable)
end
end
|
[
"def",
"add_variable",
"(",
"variable",
",",
"scope",
"=",
"current_scope",
")",
"if",
"variable_stack",
".",
"empty?",
"scope",
".",
"add",
"(",
"variable",
".",
"type",
",",
"variable",
".",
"name",
",",
"variable",
")",
"else",
"variable_stack",
".",
"push",
"(",
"variable",
")",
"end",
"end"
] |
Adds a variable to the current scope of, if a the variable stack is not
empty, add it to the stack instead.
@param [RubyLint::Definition::RubyObject] variable
@param [RubyLint::Definition::RubyObject] scope
|
[
"Adds",
"a",
"variable",
"to",
"the",
"current",
"scope",
"of",
"if",
"a",
"the",
"variable",
"stack",
"is",
"not",
"empty",
"add",
"it",
"to",
"the",
"stack",
"instead",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L992-L998
|
19,017
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.create_primitive
|
def create_primitive(node, options = {})
builder = DefinitionBuilder::Primitive.new(node, self, options)
return builder.build
end
|
ruby
|
def create_primitive(node, options = {})
builder = DefinitionBuilder::Primitive.new(node, self, options)
return builder.build
end
|
[
"def",
"create_primitive",
"(",
"node",
",",
"options",
"=",
"{",
"}",
")",
"builder",
"=",
"DefinitionBuilder",
"::",
"Primitive",
".",
"new",
"(",
"node",
",",
"self",
",",
"options",
")",
"return",
"builder",
".",
"build",
"end"
] |
Creates a primitive value such as an integer.
@param [RubyLint::AST::Node] node
@param [Hash] options
|
[
"Creates",
"a",
"primitive",
"value",
"such",
"as",
"an",
"integer",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L1006-L1010
|
19,018
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.conditional_assignment
|
def conditional_assignment(variable, value, bool = true)
variable.reference_amount += 1
if current_scope.has_definition?(variable.type, variable.name) == bool
variable.value = value
current_scope.add_definition(variable)
buffer_assignment_value(variable.value)
end
end
|
ruby
|
def conditional_assignment(variable, value, bool = true)
variable.reference_amount += 1
if current_scope.has_definition?(variable.type, variable.name) == bool
variable.value = value
current_scope.add_definition(variable)
buffer_assignment_value(variable.value)
end
end
|
[
"def",
"conditional_assignment",
"(",
"variable",
",",
"value",
",",
"bool",
"=",
"true",
")",
"variable",
".",
"reference_amount",
"+=",
"1",
"if",
"current_scope",
".",
"has_definition?",
"(",
"variable",
".",
"type",
",",
"variable",
".",
"name",
")",
"==",
"bool",
"variable",
".",
"value",
"=",
"value",
"current_scope",
".",
"add_definition",
"(",
"variable",
")",
"buffer_assignment_value",
"(",
"variable",
".",
"value",
")",
"end",
"end"
] |
Performs a conditional assignment.
@param [RubyLint::Definition::RubyObject] variable
@param [RubyLint::Definition::RubyValue] value
@param [TrueClass|FalseClass] bool When set to `true` existing variables
will be overwritten.
|
[
"Performs",
"a",
"conditional",
"assignment",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L1050-L1060
|
19,019
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.definition_for_node
|
def definition_for_node(node)
if node.const? and node.children[0]
definition = ConstantPath.new(node).resolve(current_scope)
else
definition = current_scope.lookup(node.type, node.name)
end
definition = Definition::RubyObject.create_unknown unless definition
return definition
end
|
ruby
|
def definition_for_node(node)
if node.const? and node.children[0]
definition = ConstantPath.new(node).resolve(current_scope)
else
definition = current_scope.lookup(node.type, node.name)
end
definition = Definition::RubyObject.create_unknown unless definition
return definition
end
|
[
"def",
"definition_for_node",
"(",
"node",
")",
"if",
"node",
".",
"const?",
"and",
"node",
".",
"children",
"[",
"0",
"]",
"definition",
"=",
"ConstantPath",
".",
"new",
"(",
"node",
")",
".",
"resolve",
"(",
"current_scope",
")",
"else",
"definition",
"=",
"current_scope",
".",
"lookup",
"(",
"node",
".",
"type",
",",
"node",
".",
"name",
")",
"end",
"definition",
"=",
"Definition",
"::",
"RubyObject",
".",
"create_unknown",
"unless",
"definition",
"return",
"definition",
"end"
] |
Returns the definition for the given node.
@param [RubyLint::AST::Node] node
@return [RubyLint::Definition::RubyObject]
|
[
"Returns",
"the",
"definition",
"for",
"the",
"given",
"node",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L1068-L1078
|
19,020
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.increment_reference_amount
|
def increment_reference_amount(node)
definition = definition_for_node(node)
if definition and !definition.frozen?
definition.reference_amount += 1
end
end
|
ruby
|
def increment_reference_amount(node)
definition = definition_for_node(node)
if definition and !definition.frozen?
definition.reference_amount += 1
end
end
|
[
"def",
"increment_reference_amount",
"(",
"node",
")",
"definition",
"=",
"definition_for_node",
"(",
"node",
")",
"if",
"definition",
"and",
"!",
"definition",
".",
"frozen?",
"definition",
".",
"reference_amount",
"+=",
"1",
"end",
"end"
] |
Increments the reference amount of a node's definition unless the
definition is frozen.
@param [RubyLint::AST::Node] node
|
[
"Increments",
"the",
"reference",
"amount",
"of",
"a",
"node",
"s",
"definition",
"unless",
"the",
"definition",
"is",
"frozen",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L1086-L1092
|
19,021
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.inherit_definition
|
def inherit_definition(definition, inherit)
unless definition.parents.include?(inherit)
definition.parents << inherit
end
end
|
ruby
|
def inherit_definition(definition, inherit)
unless definition.parents.include?(inherit)
definition.parents << inherit
end
end
|
[
"def",
"inherit_definition",
"(",
"definition",
",",
"inherit",
")",
"unless",
"definition",
".",
"parents",
".",
"include?",
"(",
"inherit",
")",
"definition",
".",
"parents",
"<<",
"inherit",
"end",
"end"
] |
Includes the definition `inherit` in the list of parent definitions of
`definition`.
@param [RubyLint::Definition::RubyObject] definition
@param [RubyLint::Definition::RubyObject] inherit
|
[
"Includes",
"the",
"definition",
"inherit",
"in",
"the",
"list",
"of",
"parent",
"definitions",
"of",
"definition",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L1101-L1105
|
19,022
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.buffer_docstring_tags
|
def buffer_docstring_tags(node)
return unless comments[node]
parser = Docstring::Parser.new
tags = parser.parse(comments[node].map(&:text))
@docstring_tags = Docstring::Mapping.new(tags)
end
|
ruby
|
def buffer_docstring_tags(node)
return unless comments[node]
parser = Docstring::Parser.new
tags = parser.parse(comments[node].map(&:text))
@docstring_tags = Docstring::Mapping.new(tags)
end
|
[
"def",
"buffer_docstring_tags",
"(",
"node",
")",
"return",
"unless",
"comments",
"[",
"node",
"]",
"parser",
"=",
"Docstring",
"::",
"Parser",
".",
"new",
"tags",
"=",
"parser",
".",
"parse",
"(",
"comments",
"[",
"node",
"]",
".",
"map",
"(",
":text",
")",
")",
"@docstring_tags",
"=",
"Docstring",
"::",
"Mapping",
".",
"new",
"(",
"tags",
")",
"end"
] |
Extracts all the docstring tags from the documentation of the given
node, retrieves the corresponding types and stores them for later use.
@param [RubyLint::AST::Node] node
|
[
"Extracts",
"all",
"the",
"docstring",
"tags",
"from",
"the",
"documentation",
"of",
"the",
"given",
"node",
"retrieves",
"the",
"corresponding",
"types",
"and",
"stores",
"them",
"for",
"later",
"use",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L1113-L1120
|
19,023
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.create_unknown_with_method
|
def create_unknown_with_method(name)
definition = Definition::RubyObject.create_unknown
definition.send("define_#{@method_type}", name)
return definition
end
|
ruby
|
def create_unknown_with_method(name)
definition = Definition::RubyObject.create_unknown
definition.send("define_#{@method_type}", name)
return definition
end
|
[
"def",
"create_unknown_with_method",
"(",
"name",
")",
"definition",
"=",
"Definition",
"::",
"RubyObject",
".",
"create_unknown",
"definition",
".",
"send",
"(",
"\"define_#{@method_type}\"",
",",
"name",
")",
"return",
"definition",
"end"
] |
Creates an "unknown" definition with the given method in it.
@param [String] name The name of the method to add.
@return [RubyLint::Definition::RubyObject]
|
[
"Creates",
"an",
"unknown",
"definition",
"with",
"the",
"given",
"method",
"in",
"it",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L1148-L1154
|
19,024
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.definitions_for_types
|
def definitions_for_types(types)
definitions = []
# There are basically two type signatures: either the name(s) of a
# constant or a method in the form of `#method_name`.
types.each do |type|
if type[0] == '#'
found = create_unknown_with_method(type[1..-1])
else
found = lookup_type_definition(type)
end
definitions << found if found
end
return definitions
end
|
ruby
|
def definitions_for_types(types)
definitions = []
# There are basically two type signatures: either the name(s) of a
# constant or a method in the form of `#method_name`.
types.each do |type|
if type[0] == '#'
found = create_unknown_with_method(type[1..-1])
else
found = lookup_type_definition(type)
end
definitions << found if found
end
return definitions
end
|
[
"def",
"definitions_for_types",
"(",
"types",
")",
"definitions",
"=",
"[",
"]",
"# There are basically two type signatures: either the name(s) of a",
"# constant or a method in the form of `#method_name`.",
"types",
".",
"each",
"do",
"|",
"type",
"|",
"if",
"type",
"[",
"0",
"]",
"==",
"'#'",
"found",
"=",
"create_unknown_with_method",
"(",
"type",
"[",
"1",
"..",
"-",
"1",
"]",
")",
"else",
"found",
"=",
"lookup_type_definition",
"(",
"type",
")",
"end",
"definitions",
"<<",
"found",
"if",
"found",
"end",
"return",
"definitions",
"end"
] |
Returns a collection of definitions for a set of YARD types.
@param [Array] types
@return [Array]
|
[
"Returns",
"a",
"collection",
"of",
"definitions",
"for",
"a",
"set",
"of",
"YARD",
"types",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L1162-L1178
|
19,025
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/virtual_machine.rb
|
RubyLint.VirtualMachine.track_method_call
|
def track_method_call(definition, name, node)
method = definition.lookup(definition.method_call_type, name)
current = current_scope
location = {
:line => node.line,
:column => node.column,
:file => node.file
}
# Add the call to the current scope if we're dealing with a writable
# method definition.
if current.respond_to?(:calls) and !current.frozen?
current.calls.push(
MethodCallInfo.new(location.merge(:definition => method))
)
end
# Add the caller to the called method, this allows for inverse lookups.
unless method.frozen?
method.callers.push(
MethodCallInfo.new(location.merge(:definition => definition))
)
end
end
|
ruby
|
def track_method_call(definition, name, node)
method = definition.lookup(definition.method_call_type, name)
current = current_scope
location = {
:line => node.line,
:column => node.column,
:file => node.file
}
# Add the call to the current scope if we're dealing with a writable
# method definition.
if current.respond_to?(:calls) and !current.frozen?
current.calls.push(
MethodCallInfo.new(location.merge(:definition => method))
)
end
# Add the caller to the called method, this allows for inverse lookups.
unless method.frozen?
method.callers.push(
MethodCallInfo.new(location.merge(:definition => definition))
)
end
end
|
[
"def",
"track_method_call",
"(",
"definition",
",",
"name",
",",
"node",
")",
"method",
"=",
"definition",
".",
"lookup",
"(",
"definition",
".",
"method_call_type",
",",
"name",
")",
"current",
"=",
"current_scope",
"location",
"=",
"{",
":line",
"=>",
"node",
".",
"line",
",",
":column",
"=>",
"node",
".",
"column",
",",
":file",
"=>",
"node",
".",
"file",
"}",
"# Add the call to the current scope if we're dealing with a writable",
"# method definition.",
"if",
"current",
".",
"respond_to?",
"(",
":calls",
")",
"and",
"!",
"current",
".",
"frozen?",
"current",
".",
"calls",
".",
"push",
"(",
"MethodCallInfo",
".",
"new",
"(",
"location",
".",
"merge",
"(",
":definition",
"=>",
"method",
")",
")",
")",
"end",
"# Add the caller to the called method, this allows for inverse lookups.",
"unless",
"method",
".",
"frozen?",
"method",
".",
"callers",
".",
"push",
"(",
"MethodCallInfo",
".",
"new",
"(",
"location",
".",
"merge",
"(",
":definition",
"=>",
"definition",
")",
")",
")",
"end",
"end"
] |
Tracks a method call.
@param [RubyLint::Definition::RubyMethod] definition
@param [String] name
@param [RubyLint::AST::Node] node
|
[
"Tracks",
"a",
"method",
"call",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/virtual_machine.rb#L1211-L1234
|
19,026
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/definition_generator.rb
|
RubyLint.DefinitionGenerator.group_constants
|
def group_constants(constants)
grouped = Hash.new { |hash, key| hash[key] = [] }
constants.each do |name|
root = name.split('::')[0]
grouped[root] << name
end
return grouped
end
|
ruby
|
def group_constants(constants)
grouped = Hash.new { |hash, key| hash[key] = [] }
constants.each do |name|
root = name.split('::')[0]
grouped[root] << name
end
return grouped
end
|
[
"def",
"group_constants",
"(",
"constants",
")",
"grouped",
"=",
"Hash",
".",
"new",
"{",
"|",
"hash",
",",
"key",
"|",
"hash",
"[",
"key",
"]",
"=",
"[",
"]",
"}",
"constants",
".",
"each",
"do",
"|",
"name",
"|",
"root",
"=",
"name",
".",
"split",
"(",
"'::'",
")",
"[",
"0",
"]",
"grouped",
"[",
"root",
"]",
"<<",
"name",
"end",
"return",
"grouped",
"end"
] |
Groups constants together based on the top level namespace segment.
@param [Array] constants
@return [Hash]
|
[
"Groups",
"constants",
"together",
"based",
"on",
"the",
"top",
"level",
"namespace",
"segment",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/definition_generator.rb#L115-L124
|
19,027
|
YorickPeterse/ruby-lint
|
lib/ruby-lint/definition_generator.rb
|
RubyLint.DefinitionGenerator.method_information
|
def method_information(inspected)
arg_mapping = argument_mapping
info = {:method => {}, :instance_method => {}}
inspected.each do |type, methods|
methods.each do |method|
args = []
method.parameters.each_with_index do |arg, index|
name = arg[1] || "arg#{index + 1}"
args << {:type => arg_mapping[arg[0]], :name => name}
end
info[type][method.name] = args
end
end
return info
end
|
ruby
|
def method_information(inspected)
arg_mapping = argument_mapping
info = {:method => {}, :instance_method => {}}
inspected.each do |type, methods|
methods.each do |method|
args = []
method.parameters.each_with_index do |arg, index|
name = arg[1] || "arg#{index + 1}"
args << {:type => arg_mapping[arg[0]], :name => name}
end
info[type][method.name] = args
end
end
return info
end
|
[
"def",
"method_information",
"(",
"inspected",
")",
"arg_mapping",
"=",
"argument_mapping",
"info",
"=",
"{",
":method",
"=>",
"{",
"}",
",",
":instance_method",
"=>",
"{",
"}",
"}",
"inspected",
".",
"each",
"do",
"|",
"type",
",",
"methods",
"|",
"methods",
".",
"each",
"do",
"|",
"method",
"|",
"args",
"=",
"[",
"]",
"method",
".",
"parameters",
".",
"each_with_index",
"do",
"|",
"arg",
",",
"index",
"|",
"name",
"=",
"arg",
"[",
"1",
"]",
"||",
"\"arg#{index + 1}\"",
"args",
"<<",
"{",
":type",
"=>",
"arg_mapping",
"[",
"arg",
"[",
"0",
"]",
"]",
",",
":name",
"=>",
"name",
"}",
"end",
"info",
"[",
"type",
"]",
"[",
"method",
".",
"name",
"]",
"=",
"args",
"end",
"end",
"return",
"info",
"end"
] |
Returns a Hash containing all the instance and class methods and their
arguments.
@param [Hash] inspected
@return [Hash]
|
[
"Returns",
"a",
"Hash",
"containing",
"all",
"the",
"instance",
"and",
"class",
"methods",
"and",
"their",
"arguments",
"."
] |
87842ae295c2283d8e02d951781189486a7cc970
|
https://github.com/YorickPeterse/ruby-lint/blob/87842ae295c2283d8e02d951781189486a7cc970/lib/ruby-lint/definition_generator.rb#L151-L169
|
19,028
|
rvm/rvm-capistrano
|
lib/rvm/capistrano/helpers/rvm_methods.rb
|
Capistrano.RvmMethods.rvm_task
|
def rvm_task(name,&block)
if fetch(:rvm_require_role,nil).nil?
task name, &block
else
task name, :roles => fetch(:rvm_require_role), &block
end
end
|
ruby
|
def rvm_task(name,&block)
if fetch(:rvm_require_role,nil).nil?
task name, &block
else
task name, :roles => fetch(:rvm_require_role), &block
end
end
|
[
"def",
"rvm_task",
"(",
"name",
",",
"&",
"block",
")",
"if",
"fetch",
"(",
":rvm_require_role",
",",
"nil",
")",
".",
"nil?",
"task",
"name",
",",
"block",
"else",
"task",
"name",
",",
":roles",
"=>",
"fetch",
"(",
":rvm_require_role",
")",
",",
"block",
"end",
"end"
] |
defined depending on which selector was used
|
[
"defined",
"depending",
"on",
"which",
"selector",
"was",
"used"
] |
61eda4140db1d80c3cb4755ab0812752620fdf66
|
https://github.com/rvm/rvm-capistrano/blob/61eda4140db1d80c3cb4755ab0812752620fdf66/lib/rvm/capistrano/helpers/rvm_methods.rb#L4-L10
|
19,029
|
rvm/rvm-capistrano
|
lib/rvm/capistrano/helpers/rvm_methods.rb
|
Capistrano.RvmMethods.rvm_user_command
|
def rvm_user_command(options={})
return '' unless rvm_type == :mixed && options[:subject_class]
rvm_user_args = rvm_user.empty? ? 'none' : rvm_user.map(&:to_s).join(' ')
rvm_bin = path_to_bin_rvm({ :with_ruby => true }.merge(options))
"#{rvm_bin} rvm user #{rvm_user_args} ; "
end
|
ruby
|
def rvm_user_command(options={})
return '' unless rvm_type == :mixed && options[:subject_class]
rvm_user_args = rvm_user.empty? ? 'none' : rvm_user.map(&:to_s).join(' ')
rvm_bin = path_to_bin_rvm({ :with_ruby => true }.merge(options))
"#{rvm_bin} rvm user #{rvm_user_args} ; "
end
|
[
"def",
"rvm_user_command",
"(",
"options",
"=",
"{",
"}",
")",
"return",
"''",
"unless",
"rvm_type",
"==",
":mixed",
"&&",
"options",
"[",
":subject_class",
"]",
"rvm_user_args",
"=",
"rvm_user",
".",
"empty?",
"?",
"'none'",
":",
"rvm_user",
".",
"map",
"(",
":to_s",
")",
".",
"join",
"(",
"' '",
")",
"rvm_bin",
"=",
"path_to_bin_rvm",
"(",
"{",
":with_ruby",
"=>",
"true",
"}",
".",
"merge",
"(",
"options",
")",
")",
"\"#{rvm_bin} rvm user #{rvm_user_args} ; \"",
"end"
] |
If we're operating on something affected by the rvm user mode,
we need to make sure that the server has the right rvm user mode.
This returns a shell command to prepend to an existing command
in order to achieve this.
|
[
"If",
"we",
"re",
"operating",
"on",
"something",
"affected",
"by",
"the",
"rvm",
"user",
"mode",
"we",
"need",
"to",
"make",
"sure",
"that",
"the",
"server",
"has",
"the",
"right",
"rvm",
"user",
"mode",
".",
"This",
"returns",
"a",
"shell",
"command",
"to",
"prepend",
"to",
"an",
"existing",
"command",
"in",
"order",
"to",
"achieve",
"this",
"."
] |
61eda4140db1d80c3cb4755ab0812752620fdf66
|
https://github.com/rvm/rvm-capistrano/blob/61eda4140db1d80c3cb4755ab0812752620fdf66/lib/rvm/capistrano/helpers/rvm_methods.rb#L42-L47
|
19,030
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.set_x_axis
|
def set_x_axis(params)
name, encoding = encode_utf16(params[:name], params[:name_encoding])
formula = parse_series_formula(params[:name_formula])
@x_axis_name = name
@x_axis_encoding = encoding
@x_axis_formula = formula
end
|
ruby
|
def set_x_axis(params)
name, encoding = encode_utf16(params[:name], params[:name_encoding])
formula = parse_series_formula(params[:name_formula])
@x_axis_name = name
@x_axis_encoding = encoding
@x_axis_formula = formula
end
|
[
"def",
"set_x_axis",
"(",
"params",
")",
"name",
",",
"encoding",
"=",
"encode_utf16",
"(",
"params",
"[",
":name",
"]",
",",
"params",
"[",
":name_encoding",
"]",
")",
"formula",
"=",
"parse_series_formula",
"(",
"params",
"[",
":name_formula",
"]",
")",
"@x_axis_name",
"=",
"name",
"@x_axis_encoding",
"=",
"encoding",
"@x_axis_formula",
"=",
"formula",
"end"
] |
Set the properties of the X-axis.
The set_x_axis() method is used to set properties of the X axis.
chart.set_x_axis(:name => 'Sample length (m)' )
The properties that can be set are:
:name (optional)
:name_formula (optional)
* :name
Set the name (title or caption) for the axis. The name is displayed
below the X axis. This property is optional. The default is to have
no axis name.
chart.set_x_axis( :name => 'Sample length (m)' )
* :name_formula
Optional, can be used to link the name to a worksheet cell.
See "Chart names and links".
chart.set_x_axis(
:name => 'Sample length (m)',
:name_formula => '=Sheet1!$A$1'
)
Additional axis properties such as range, divisions and ticks will be made
available in later releases.
|
[
"Set",
"the",
"properties",
"of",
"the",
"X",
"-",
"axis",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L254-L261
|
19,031
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.set_y_axis
|
def set_y_axis(params)
name, encoding = encode_utf16(params[:name], params[:name_encoding])
formula = parse_series_formula(params[:name_formula])
@y_axis_name = name
@y_axis_encoding = encoding
@y_axis_formula = formula
end
|
ruby
|
def set_y_axis(params)
name, encoding = encode_utf16(params[:name], params[:name_encoding])
formula = parse_series_formula(params[:name_formula])
@y_axis_name = name
@y_axis_encoding = encoding
@y_axis_formula = formula
end
|
[
"def",
"set_y_axis",
"(",
"params",
")",
"name",
",",
"encoding",
"=",
"encode_utf16",
"(",
"params",
"[",
":name",
"]",
",",
"params",
"[",
":name_encoding",
"]",
")",
"formula",
"=",
"parse_series_formula",
"(",
"params",
"[",
":name_formula",
"]",
")",
"@y_axis_name",
"=",
"name",
"@y_axis_encoding",
"=",
"encoding",
"@y_axis_formula",
"=",
"formula",
"end"
] |
Set the properties of the Y-axis.
The set_y_axis() method is used to set properties of the Y axis.
chart.set_y_axis(:name => 'Sample weight (kg)' )
The properties that can be set are:
:name (optional)
:name_formula (optional)
* :name
Set the name (title or caption) for the axis. The name is displayed
to the left of the Y axis. This property is optional. The default
is to have no axis name.
chart.set_y_axis(:name => 'Sample weight (kg)' )
* :name_formula
Optional, can be used to link the name to a worksheet cell.
See "Chart names and links".
chart.set_y_axis(
:name => 'Sample weight (kg)',
:name_formula => '=Sheet1!$B$1'
)
Additional axis properties such as range, divisions and ticks will be made
available in later releases.
|
[
"Set",
"the",
"properties",
"of",
"the",
"Y",
"-",
"axis",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L296-L303
|
19,032
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.set_plotarea
|
def set_plotarea(params = {})
return if params.empty?
area = @plotarea
# Set the plotarea visibility.
if params.has_key?(:visible)
area[:visible] = params[:visible]
return if area[:visible] == 0
end
# TODO. could move this out of if statement.
area[:bg_color_index] = 0x08
# Set the chart background colour.
if params.has_key?(:color)
index, rgb = get_color_indices(params[:color])
if !index.nil?
area[:fg_color_index] = index
area[:fg_color_rgb] = rgb
area[:bg_color_index] = 0x08
area[:bg_color_rgb] = 0x000000
end
end
# Set the border line colour.
if params.has_key?(:line_color)
index, rgb = get_color_indices(params[:line_color])
if !index.nil?
area[:line_color_index] = index
area[:line_color_rgb] = rgb
end
end
# Set the border line pattern.
if params.has_key?(:line_pattern)
pattern = get_line_pattern(params[:line_pattern])
area[:line_pattern] = pattern
end
# Set the border line weight.
if params.has_key?(:line_weight)
weight = get_line_weight(params[:line_weight])
area[:line_weight] = weight
end
end
|
ruby
|
def set_plotarea(params = {})
return if params.empty?
area = @plotarea
# Set the plotarea visibility.
if params.has_key?(:visible)
area[:visible] = params[:visible]
return if area[:visible] == 0
end
# TODO. could move this out of if statement.
area[:bg_color_index] = 0x08
# Set the chart background colour.
if params.has_key?(:color)
index, rgb = get_color_indices(params[:color])
if !index.nil?
area[:fg_color_index] = index
area[:fg_color_rgb] = rgb
area[:bg_color_index] = 0x08
area[:bg_color_rgb] = 0x000000
end
end
# Set the border line colour.
if params.has_key?(:line_color)
index, rgb = get_color_indices(params[:line_color])
if !index.nil?
area[:line_color_index] = index
area[:line_color_rgb] = rgb
end
end
# Set the border line pattern.
if params.has_key?(:line_pattern)
pattern = get_line_pattern(params[:line_pattern])
area[:line_pattern] = pattern
end
# Set the border line weight.
if params.has_key?(:line_weight)
weight = get_line_weight(params[:line_weight])
area[:line_weight] = weight
end
end
|
[
"def",
"set_plotarea",
"(",
"params",
"=",
"{",
"}",
")",
"return",
"if",
"params",
".",
"empty?",
"area",
"=",
"@plotarea",
"# Set the plotarea visibility.",
"if",
"params",
".",
"has_key?",
"(",
":visible",
")",
"area",
"[",
":visible",
"]",
"=",
"params",
"[",
":visible",
"]",
"return",
"if",
"area",
"[",
":visible",
"]",
"==",
"0",
"end",
"# TODO. could move this out of if statement.",
"area",
"[",
":bg_color_index",
"]",
"=",
"0x08",
"# Set the chart background colour.",
"if",
"params",
".",
"has_key?",
"(",
":color",
")",
"index",
",",
"rgb",
"=",
"get_color_indices",
"(",
"params",
"[",
":color",
"]",
")",
"if",
"!",
"index",
".",
"nil?",
"area",
"[",
":fg_color_index",
"]",
"=",
"index",
"area",
"[",
":fg_color_rgb",
"]",
"=",
"rgb",
"area",
"[",
":bg_color_index",
"]",
"=",
"0x08",
"area",
"[",
":bg_color_rgb",
"]",
"=",
"0x000000",
"end",
"end",
"# Set the border line colour.",
"if",
"params",
".",
"has_key?",
"(",
":line_color",
")",
"index",
",",
"rgb",
"=",
"get_color_indices",
"(",
"params",
"[",
":line_color",
"]",
")",
"if",
"!",
"index",
".",
"nil?",
"area",
"[",
":line_color_index",
"]",
"=",
"index",
"area",
"[",
":line_color_rgb",
"]",
"=",
"rgb",
"end",
"end",
"# Set the border line pattern.",
"if",
"params",
".",
"has_key?",
"(",
":line_pattern",
")",
"pattern",
"=",
"get_line_pattern",
"(",
"params",
"[",
":line_pattern",
"]",
")",
"area",
"[",
":line_pattern",
"]",
"=",
"pattern",
"end",
"# Set the border line weight.",
"if",
"params",
".",
"has_key?",
"(",
":line_weight",
")",
"weight",
"=",
"get_line_weight",
"(",
"params",
"[",
":line_weight",
"]",
")",
"area",
"[",
":line_weight",
"]",
"=",
"weight",
"end",
"end"
] |
Set the properties of the chart plotarea.
|
[
"Set",
"the",
"properties",
"of",
"the",
"chart",
"plotarea",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L357-L402
|
19,033
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.close
|
def close # :nodoc:
# Ignore any data that has been written so far since it is probably
# from unwanted Worksheet method calls.
@data = ''
# TODO. Check for charts without a series?
# Store the chart BOF.
store_bof(0x0020)
# Store the page header
store_header
# Store the page footer
store_footer
# Store the page horizontal centering
store_hcenter
# Store the page vertical centering
store_vcenter
# Store the left margin
store_margin_left
# Store the right margin
store_margin_right
# Store the top margin
store_margin_top
# Store the bottom margin
store_margin_bottom
# Store the page setup
store_setup
# Store the sheet password
store_password
# Start of Chart specific records.
# Store the FBI font records.
store_fbi(*@config[:font_numbers])
store_fbi(*@config[:font_series])
store_fbi(*@config[:font_title])
store_fbi(*@config[:font_axes])
# Ignore UNITS record.
# Store the Chart sub-stream.
store_chart_stream
# Append the sheet dimensions
store_dimensions
# TODO add SINDEX and NUMBER records.
store_window2 unless @embedded
store_eof
end
|
ruby
|
def close # :nodoc:
# Ignore any data that has been written so far since it is probably
# from unwanted Worksheet method calls.
@data = ''
# TODO. Check for charts without a series?
# Store the chart BOF.
store_bof(0x0020)
# Store the page header
store_header
# Store the page footer
store_footer
# Store the page horizontal centering
store_hcenter
# Store the page vertical centering
store_vcenter
# Store the left margin
store_margin_left
# Store the right margin
store_margin_right
# Store the top margin
store_margin_top
# Store the bottom margin
store_margin_bottom
# Store the page setup
store_setup
# Store the sheet password
store_password
# Start of Chart specific records.
# Store the FBI font records.
store_fbi(*@config[:font_numbers])
store_fbi(*@config[:font_series])
store_fbi(*@config[:font_title])
store_fbi(*@config[:font_axes])
# Ignore UNITS record.
# Store the Chart sub-stream.
store_chart_stream
# Append the sheet dimensions
store_dimensions
# TODO add SINDEX and NUMBER records.
store_window2 unless @embedded
store_eof
end
|
[
"def",
"close",
"# :nodoc:",
"# Ignore any data that has been written so far since it is probably",
"# from unwanted Worksheet method calls.",
"@data",
"=",
"''",
"# TODO. Check for charts without a series?",
"# Store the chart BOF.",
"store_bof",
"(",
"0x0020",
")",
"# Store the page header",
"store_header",
"# Store the page footer",
"store_footer",
"# Store the page horizontal centering",
"store_hcenter",
"# Store the page vertical centering",
"store_vcenter",
"# Store the left margin",
"store_margin_left",
"# Store the right margin",
"store_margin_right",
"# Store the top margin",
"store_margin_top",
"# Store the bottom margin",
"store_margin_bottom",
"# Store the page setup",
"store_setup",
"# Store the sheet password",
"store_password",
"# Start of Chart specific records.",
"# Store the FBI font records.",
"store_fbi",
"(",
"@config",
"[",
":font_numbers",
"]",
")",
"store_fbi",
"(",
"@config",
"[",
":font_series",
"]",
")",
"store_fbi",
"(",
"@config",
"[",
":font_title",
"]",
")",
"store_fbi",
"(",
"@config",
"[",
":font_axes",
"]",
")",
"# Ignore UNITS record.",
"# Store the Chart sub-stream.",
"store_chart_stream",
"# Append the sheet dimensions",
"store_dimensions",
"# TODO add SINDEX and NUMBER records.",
"store_window2",
"unless",
"@embedded",
"store_eof",
"end"
] |
Create and store the Chart data structures.
|
[
"Create",
"and",
"store",
"the",
"Chart",
"data",
"structures",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L521-L582
|
19,034
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_window2
|
def store_window2 # :nodoc:
record = 0x023E # Record identifier
length = 0x000A # Number of bytes to follow
grbit = 0x0000 # Option flags
rwTop = 0x0000 # Top visible row
colLeft = 0x0000 # Leftmost visible column
rgbHdr = 0x0000 # Row/col heading, grid color
# The options flags that comprise grbit
fDspFmla = 0 # 0 - bit
fDspGrid = 0 # 1
fDspRwCol = 0 # 2
fFrozen = 0 # 3
fDspZeros = 0 # 4
fDefaultHdr = 0 # 5
fArabic = 0 # 6
fDspGuts = 0 # 7
fFrozenNoSplit = 0 # 0 - bit
fSelected = selected? ? 1 : 0 # 1
fPaged = 0 # 2
fBreakPreview = 0 # 3
#<<< Perltidy ignore this.
grbit = fDspFmla
grbit |= fDspGrid << 1
grbit |= fDspRwCol << 2
grbit |= fFrozen << 3
grbit |= fDspZeros << 4
grbit |= fDefaultHdr << 5
grbit |= fArabic << 6
grbit |= fDspGuts << 7
grbit |= fFrozenNoSplit << 8
grbit |= fSelected << 9
grbit |= fPaged << 10
grbit |= fBreakPreview << 11
#>>>
header = [record, length].pack("vv")
data = [grbit, rwTop, colLeft, rgbHdr].pack("vvvV")
append(header, data)
end
|
ruby
|
def store_window2 # :nodoc:
record = 0x023E # Record identifier
length = 0x000A # Number of bytes to follow
grbit = 0x0000 # Option flags
rwTop = 0x0000 # Top visible row
colLeft = 0x0000 # Leftmost visible column
rgbHdr = 0x0000 # Row/col heading, grid color
# The options flags that comprise grbit
fDspFmla = 0 # 0 - bit
fDspGrid = 0 # 1
fDspRwCol = 0 # 2
fFrozen = 0 # 3
fDspZeros = 0 # 4
fDefaultHdr = 0 # 5
fArabic = 0 # 6
fDspGuts = 0 # 7
fFrozenNoSplit = 0 # 0 - bit
fSelected = selected? ? 1 : 0 # 1
fPaged = 0 # 2
fBreakPreview = 0 # 3
#<<< Perltidy ignore this.
grbit = fDspFmla
grbit |= fDspGrid << 1
grbit |= fDspRwCol << 2
grbit |= fFrozen << 3
grbit |= fDspZeros << 4
grbit |= fDefaultHdr << 5
grbit |= fArabic << 6
grbit |= fDspGuts << 7
grbit |= fFrozenNoSplit << 8
grbit |= fSelected << 9
grbit |= fPaged << 10
grbit |= fBreakPreview << 11
#>>>
header = [record, length].pack("vv")
data = [grbit, rwTop, colLeft, rgbHdr].pack("vvvV")
append(header, data)
end
|
[
"def",
"store_window2",
"# :nodoc:",
"record",
"=",
"0x023E",
"# Record identifier",
"length",
"=",
"0x000A",
"# Number of bytes to follow",
"grbit",
"=",
"0x0000",
"# Option flags",
"rwTop",
"=",
"0x0000",
"# Top visible row",
"colLeft",
"=",
"0x0000",
"# Leftmost visible column",
"rgbHdr",
"=",
"0x0000",
"# Row/col heading, grid color",
"# The options flags that comprise grbit",
"fDspFmla",
"=",
"0",
"# 0 - bit",
"fDspGrid",
"=",
"0",
"# 1",
"fDspRwCol",
"=",
"0",
"# 2",
"fFrozen",
"=",
"0",
"# 3",
"fDspZeros",
"=",
"0",
"# 4",
"fDefaultHdr",
"=",
"0",
"# 5",
"fArabic",
"=",
"0",
"# 6",
"fDspGuts",
"=",
"0",
"# 7",
"fFrozenNoSplit",
"=",
"0",
"# 0 - bit",
"fSelected",
"=",
"selected?",
"?",
"1",
":",
"0",
"# 1",
"fPaged",
"=",
"0",
"# 2",
"fBreakPreview",
"=",
"0",
"# 3",
"#<<< Perltidy ignore this.",
"grbit",
"=",
"fDspFmla",
"grbit",
"|=",
"fDspGrid",
"<<",
"1",
"grbit",
"|=",
"fDspRwCol",
"<<",
"2",
"grbit",
"|=",
"fFrozen",
"<<",
"3",
"grbit",
"|=",
"fDspZeros",
"<<",
"4",
"grbit",
"|=",
"fDefaultHdr",
"<<",
"5",
"grbit",
"|=",
"fArabic",
"<<",
"6",
"grbit",
"|=",
"fDspGuts",
"<<",
"7",
"grbit",
"|=",
"fFrozenNoSplit",
"<<",
"8",
"grbit",
"|=",
"fSelected",
"<<",
"9",
"grbit",
"|=",
"fPaged",
"<<",
"10",
"grbit",
"|=",
"fBreakPreview",
"<<",
"11",
"#>>>",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"\"vv\"",
")",
"data",
"=",
"[",
"grbit",
",",
"rwTop",
",",
"colLeft",
",",
"rgbHdr",
"]",
".",
"pack",
"(",
"\"vvvV\"",
")",
"append",
"(",
"header",
",",
"data",
")",
"end"
] |
Write BIFF record Window2. Note, this overrides the parent Worksheet
record because the Chart version of the record is smaller and is used
mainly to indicate if the chart tab is selected or not.
|
[
"Write",
"BIFF",
"record",
"Window2",
".",
"Note",
"this",
"overrides",
"the",
"parent",
"Worksheet",
"record",
"because",
"the",
"Chart",
"version",
"of",
"the",
"record",
"is",
"smaller",
"and",
"is",
"used",
"mainly",
"to",
"indicate",
"if",
"the",
"chart",
"tab",
"is",
"selected",
"or",
"not",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L604-L645
|
19,035
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.encode_utf16
|
def encode_utf16(str, encoding = 0) # :nodoc:
# Exit if the $string isn't defined, i.e., hasn't been set by user.
return [nil, nil] if str.nil?
string = str.dup
# Return if encoding is set, i.e., string has been manually encoded.
#return ( undef, undef ) if $string == 1;
ruby_19 { string = convert_to_ascii_if_ascii(string) }
# Handle utf8 strings.
if is_utf8?(string)
string = utf8_to_16be(string)
encoding = 1
end
# Chart strings are limited to 255 characters.
limit = encoding != 0 ? 255 * 2 : 255
if string.bytesize >= limit
# truncate the string and raise a warning.
string = string[0, limit]
end
[string, encoding]
end
|
ruby
|
def encode_utf16(str, encoding = 0) # :nodoc:
# Exit if the $string isn't defined, i.e., hasn't been set by user.
return [nil, nil] if str.nil?
string = str.dup
# Return if encoding is set, i.e., string has been manually encoded.
#return ( undef, undef ) if $string == 1;
ruby_19 { string = convert_to_ascii_if_ascii(string) }
# Handle utf8 strings.
if is_utf8?(string)
string = utf8_to_16be(string)
encoding = 1
end
# Chart strings are limited to 255 characters.
limit = encoding != 0 ? 255 * 2 : 255
if string.bytesize >= limit
# truncate the string and raise a warning.
string = string[0, limit]
end
[string, encoding]
end
|
[
"def",
"encode_utf16",
"(",
"str",
",",
"encoding",
"=",
"0",
")",
"# :nodoc:",
"# Exit if the $string isn't defined, i.e., hasn't been set by user.",
"return",
"[",
"nil",
",",
"nil",
"]",
"if",
"str",
".",
"nil?",
"string",
"=",
"str",
".",
"dup",
"# Return if encoding is set, i.e., string has been manually encoded.",
"#return ( undef, undef ) if $string == 1;",
"ruby_19",
"{",
"string",
"=",
"convert_to_ascii_if_ascii",
"(",
"string",
")",
"}",
"# Handle utf8 strings.",
"if",
"is_utf8?",
"(",
"string",
")",
"string",
"=",
"utf8_to_16be",
"(",
"string",
")",
"encoding",
"=",
"1",
"end",
"# Chart strings are limited to 255 characters.",
"limit",
"=",
"encoding",
"!=",
"0",
"?",
"255",
"*",
"2",
":",
"255",
"if",
"string",
".",
"bytesize",
">=",
"limit",
"# truncate the string and raise a warning.",
"string",
"=",
"string",
"[",
"0",
",",
"limit",
"]",
"end",
"[",
"string",
",",
"encoding",
"]",
"end"
] |
Convert UTF8 strings used in the chart to UTF16.
|
[
"Convert",
"UTF8",
"strings",
"used",
"in",
"the",
"chart",
"to",
"UTF16",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L692-L717
|
19,036
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.get_color_indices
|
def get_color_indices(color) # :nodoc:
invalid = 0x7FFF # return from Colors#get_color when color is invalid
index = Colors.new.get_color(color)
index = invalid if color.respond_to?(:coerce) && (color < 8 || color > 63)
if index == invalid
[nil, nil]
else
[index, get_color_rbg(index)]
end
end
|
ruby
|
def get_color_indices(color) # :nodoc:
invalid = 0x7FFF # return from Colors#get_color when color is invalid
index = Colors.new.get_color(color)
index = invalid if color.respond_to?(:coerce) && (color < 8 || color > 63)
if index == invalid
[nil, nil]
else
[index, get_color_rbg(index)]
end
end
|
[
"def",
"get_color_indices",
"(",
"color",
")",
"# :nodoc:",
"invalid",
"=",
"0x7FFF",
"# return from Colors#get_color when color is invalid",
"index",
"=",
"Colors",
".",
"new",
".",
"get_color",
"(",
"color",
")",
"index",
"=",
"invalid",
"if",
"color",
".",
"respond_to?",
"(",
":coerce",
")",
"&&",
"(",
"color",
"<",
"8",
"||",
"color",
">",
"63",
")",
"if",
"index",
"==",
"invalid",
"[",
"nil",
",",
"nil",
"]",
"else",
"[",
"index",
",",
"get_color_rbg",
"(",
"index",
")",
"]",
"end",
"end"
] |
Convert the user specified colour index or string to an colour index and
RGB colour number.
|
[
"Convert",
"the",
"user",
"specified",
"colour",
"index",
"or",
"string",
"to",
"an",
"colour",
"index",
"and",
"RGB",
"colour",
"number",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L723-L733
|
19,037
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.get_line_pattern
|
def get_line_pattern(value) # :nodoc:
value = value.downcase if value.respond_to?(:to_str)
default = 0
patterns = {
0 => 5,
1 => 0,
2 => 1,
3 => 2,
4 => 3,
5 => 4,
6 => 7,
7 => 6,
8 => 8,
'solid' => 0,
'dash' => 1,
'dot' => 2,
'dash-dot' => 3,
'dash-dot-dot' => 4,
'none' => 5,
'dark-gray' => 6,
'medium-gray' => 7,
'light-gray' => 8,
}
if patterns.has_key?(value)
patterns[value]
else
default
end
end
|
ruby
|
def get_line_pattern(value) # :nodoc:
value = value.downcase if value.respond_to?(:to_str)
default = 0
patterns = {
0 => 5,
1 => 0,
2 => 1,
3 => 2,
4 => 3,
5 => 4,
6 => 7,
7 => 6,
8 => 8,
'solid' => 0,
'dash' => 1,
'dot' => 2,
'dash-dot' => 3,
'dash-dot-dot' => 4,
'none' => 5,
'dark-gray' => 6,
'medium-gray' => 7,
'light-gray' => 8,
}
if patterns.has_key?(value)
patterns[value]
else
default
end
end
|
[
"def",
"get_line_pattern",
"(",
"value",
")",
"# :nodoc:",
"value",
"=",
"value",
".",
"downcase",
"if",
"value",
".",
"respond_to?",
"(",
":to_str",
")",
"default",
"=",
"0",
"patterns",
"=",
"{",
"0",
"=>",
"5",
",",
"1",
"=>",
"0",
",",
"2",
"=>",
"1",
",",
"3",
"=>",
"2",
",",
"4",
"=>",
"3",
",",
"5",
"=>",
"4",
",",
"6",
"=>",
"7",
",",
"7",
"=>",
"6",
",",
"8",
"=>",
"8",
",",
"'solid'",
"=>",
"0",
",",
"'dash'",
"=>",
"1",
",",
"'dot'",
"=>",
"2",
",",
"'dash-dot'",
"=>",
"3",
",",
"'dash-dot-dot'",
"=>",
"4",
",",
"'none'",
"=>",
"5",
",",
"'dark-gray'",
"=>",
"6",
",",
"'medium-gray'",
"=>",
"7",
",",
"'light-gray'",
"=>",
"8",
",",
"}",
"if",
"patterns",
".",
"has_key?",
"(",
"value",
")",
"patterns",
"[",
"value",
"]",
"else",
"default",
"end",
"end"
] |
Get the Excel chart index for line pattern that corresponds to the user
defined value.
|
[
"Get",
"the",
"Excel",
"chart",
"index",
"for",
"line",
"pattern",
"that",
"corresponds",
"to",
"the",
"user",
"defined",
"value",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L754-L784
|
19,038
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.get_line_weight
|
def get_line_weight(value) # :nodoc:
value = value.downcase if value.respond_to?(:to_str)
default = 0
weights = {
1 => -1,
2 => 0,
3 => 1,
4 => 2,
'hairline' => -1,
'narrow' => 0,
'medium' => 1,
'wide' => 2,
}
if weights.has_key?(value)
weights[value]
else
default
end
end
|
ruby
|
def get_line_weight(value) # :nodoc:
value = value.downcase if value.respond_to?(:to_str)
default = 0
weights = {
1 => -1,
2 => 0,
3 => 1,
4 => 2,
'hairline' => -1,
'narrow' => 0,
'medium' => 1,
'wide' => 2,
}
if weights.has_key?(value)
weights[value]
else
default
end
end
|
[
"def",
"get_line_weight",
"(",
"value",
")",
"# :nodoc:",
"value",
"=",
"value",
".",
"downcase",
"if",
"value",
".",
"respond_to?",
"(",
":to_str",
")",
"default",
"=",
"0",
"weights",
"=",
"{",
"1",
"=>",
"-",
"1",
",",
"2",
"=>",
"0",
",",
"3",
"=>",
"1",
",",
"4",
"=>",
"2",
",",
"'hairline'",
"=>",
"-",
"1",
",",
"'narrow'",
"=>",
"0",
",",
"'medium'",
"=>",
"1",
",",
"'wide'",
"=>",
"2",
",",
"}",
"if",
"weights",
".",
"has_key?",
"(",
"value",
")",
"weights",
"[",
"value",
"]",
"else",
"default",
"end",
"end"
] |
Get the Excel chart index for line weight that corresponds to the user
defined value.
|
[
"Get",
"the",
"Excel",
"chart",
"index",
"for",
"line",
"weight",
"that",
"corresponds",
"to",
"the",
"user",
"defined",
"value",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L790-L810
|
19,039
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_chart_stream
|
def store_chart_stream # :nodoc:
store_chart(*@config[:chart])
store_begin
# Store the chart SCL record.
store_plotgrowth
if @chartarea[:visible] != 0
store_chartarea_frame_stream
end
# Store SERIES stream for each series.
index = 0
@series.each do |series|
store_series_stream(
:index => index,
:value_formula => series[:values][0],
:value_count => series[:values][1],
:category_count => series[:categories][1],
:category_formula => series[:categories][0],
:name => series[:name],
:name_encoding => series[:name_encoding],
:name_formula => series[:name_formula]
)
index += 1
end
store_shtprops
# Write the TEXT streams.
(5..6).each do |font_index|
store_defaulttext
store_series_text_stream(font_index)
end
store_axesused(1)
store_axisparent_stream
if !@title_name.nil? || !@title_formula.nil?
store_title_text_stream
end
store_end
end
|
ruby
|
def store_chart_stream # :nodoc:
store_chart(*@config[:chart])
store_begin
# Store the chart SCL record.
store_plotgrowth
if @chartarea[:visible] != 0
store_chartarea_frame_stream
end
# Store SERIES stream for each series.
index = 0
@series.each do |series|
store_series_stream(
:index => index,
:value_formula => series[:values][0],
:value_count => series[:values][1],
:category_count => series[:categories][1],
:category_formula => series[:categories][0],
:name => series[:name],
:name_encoding => series[:name_encoding],
:name_formula => series[:name_formula]
)
index += 1
end
store_shtprops
# Write the TEXT streams.
(5..6).each do |font_index|
store_defaulttext
store_series_text_stream(font_index)
end
store_axesused(1)
store_axisparent_stream
if !@title_name.nil? || !@title_formula.nil?
store_title_text_stream
end
store_end
end
|
[
"def",
"store_chart_stream",
"# :nodoc:",
"store_chart",
"(",
"@config",
"[",
":chart",
"]",
")",
"store_begin",
"# Store the chart SCL record.",
"store_plotgrowth",
"if",
"@chartarea",
"[",
":visible",
"]",
"!=",
"0",
"store_chartarea_frame_stream",
"end",
"# Store SERIES stream for each series.",
"index",
"=",
"0",
"@series",
".",
"each",
"do",
"|",
"series",
"|",
"store_series_stream",
"(",
":index",
"=>",
"index",
",",
":value_formula",
"=>",
"series",
"[",
":values",
"]",
"[",
"0",
"]",
",",
":value_count",
"=>",
"series",
"[",
":values",
"]",
"[",
"1",
"]",
",",
":category_count",
"=>",
"series",
"[",
":categories",
"]",
"[",
"1",
"]",
",",
":category_formula",
"=>",
"series",
"[",
":categories",
"]",
"[",
"0",
"]",
",",
":name",
"=>",
"series",
"[",
":name",
"]",
",",
":name_encoding",
"=>",
"series",
"[",
":name_encoding",
"]",
",",
":name_formula",
"=>",
"series",
"[",
":name_formula",
"]",
")",
"index",
"+=",
"1",
"end",
"store_shtprops",
"# Write the TEXT streams.",
"(",
"5",
"..",
"6",
")",
".",
"each",
"do",
"|",
"font_index",
"|",
"store_defaulttext",
"store_series_text_stream",
"(",
"font_index",
")",
"end",
"store_axesused",
"(",
"1",
")",
"store_axisparent_stream",
"if",
"!",
"@title_name",
".",
"nil?",
"||",
"!",
"@title_formula",
".",
"nil?",
"store_title_text_stream",
"end",
"store_end",
"end"
] |
Store the CHART record and it's substreams.
|
[
"Store",
"the",
"CHART",
"record",
"and",
"it",
"s",
"substreams",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L815-L858
|
19,040
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_series_stream
|
def store_series_stream(params) # :nodoc:
name_type = _formula_type_from_param(2, 1, params, :name_formula)
value_type = _formula_type_from_param(2, 0, params, :value_formula)
category_type = _formula_type_from_param(2, 0, params, :category_formula)
store_series(params[:value_count], params[:category_count])
store_begin
# Store the Series name AI record.
store_ai(0, name_type, params[:name_formula])
unless params[:name].nil?
store_seriestext(params[:name], params[:name_encoding])
end
store_ai(1, value_type, params[:value_formula])
store_ai(2, category_type, params[:category_formula])
store_ai(3, 1, '' )
store_dataformat_stream(params[:index])
store_sertocrt
store_end
end
|
ruby
|
def store_series_stream(params) # :nodoc:
name_type = _formula_type_from_param(2, 1, params, :name_formula)
value_type = _formula_type_from_param(2, 0, params, :value_formula)
category_type = _formula_type_from_param(2, 0, params, :category_formula)
store_series(params[:value_count], params[:category_count])
store_begin
# Store the Series name AI record.
store_ai(0, name_type, params[:name_formula])
unless params[:name].nil?
store_seriestext(params[:name], params[:name_encoding])
end
store_ai(1, value_type, params[:value_formula])
store_ai(2, category_type, params[:category_formula])
store_ai(3, 1, '' )
store_dataformat_stream(params[:index])
store_sertocrt
store_end
end
|
[
"def",
"store_series_stream",
"(",
"params",
")",
"# :nodoc:",
"name_type",
"=",
"_formula_type_from_param",
"(",
"2",
",",
"1",
",",
"params",
",",
":name_formula",
")",
"value_type",
"=",
"_formula_type_from_param",
"(",
"2",
",",
"0",
",",
"params",
",",
":value_formula",
")",
"category_type",
"=",
"_formula_type_from_param",
"(",
"2",
",",
"0",
",",
"params",
",",
":category_formula",
")",
"store_series",
"(",
"params",
"[",
":value_count",
"]",
",",
"params",
"[",
":category_count",
"]",
")",
"store_begin",
"# Store the Series name AI record.",
"store_ai",
"(",
"0",
",",
"name_type",
",",
"params",
"[",
":name_formula",
"]",
")",
"unless",
"params",
"[",
":name",
"]",
".",
"nil?",
"store_seriestext",
"(",
"params",
"[",
":name",
"]",
",",
"params",
"[",
":name_encoding",
"]",
")",
"end",
"store_ai",
"(",
"1",
",",
"value_type",
",",
"params",
"[",
":value_formula",
"]",
")",
"store_ai",
"(",
"2",
",",
"category_type",
",",
"params",
"[",
":category_formula",
"]",
")",
"store_ai",
"(",
"3",
",",
"1",
",",
"''",
")",
"store_dataformat_stream",
"(",
"params",
"[",
":index",
"]",
")",
"store_sertocrt",
"store_end",
"end"
] |
Write the SERIES chart substream.
|
[
"Write",
"the",
"SERIES",
"chart",
"substream",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L870-L892
|
19,041
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_x_axis_text_stream
|
def store_x_axis_text_stream # :nodoc:
formula = @x_axis_formula.nil? ? '' : @x_axis_formula
ai_type = _formula_type(2, 1, formula)
store_text(*@config[:x_axis_text])
store_begin
store_pos(*@config[:x_axis_text_pos])
store_fontx(8)
store_ai(0, ai_type, formula)
unless @x_axis_name.nil?
store_seriestext(@x_axis_name, @x_axis_encoding)
end
store_objectlink(3)
store_end
end
|
ruby
|
def store_x_axis_text_stream # :nodoc:
formula = @x_axis_formula.nil? ? '' : @x_axis_formula
ai_type = _formula_type(2, 1, formula)
store_text(*@config[:x_axis_text])
store_begin
store_pos(*@config[:x_axis_text_pos])
store_fontx(8)
store_ai(0, ai_type, formula)
unless @x_axis_name.nil?
store_seriestext(@x_axis_name, @x_axis_encoding)
end
store_objectlink(3)
store_end
end
|
[
"def",
"store_x_axis_text_stream",
"# :nodoc:",
"formula",
"=",
"@x_axis_formula",
".",
"nil?",
"?",
"''",
":",
"@x_axis_formula",
"ai_type",
"=",
"_formula_type",
"(",
"2",
",",
"1",
",",
"formula",
")",
"store_text",
"(",
"@config",
"[",
":x_axis_text",
"]",
")",
"store_begin",
"store_pos",
"(",
"@config",
"[",
":x_axis_text_pos",
"]",
")",
"store_fontx",
"(",
"8",
")",
"store_ai",
"(",
"0",
",",
"ai_type",
",",
"formula",
")",
"unless",
"@x_axis_name",
".",
"nil?",
"store_seriestext",
"(",
"@x_axis_name",
",",
"@x_axis_encoding",
")",
"end",
"store_objectlink",
"(",
"3",
")",
"store_end",
"end"
] |
Write the X-axis TEXT substream.
|
[
"Write",
"the",
"X",
"-",
"axis",
"TEXT",
"substream",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L925-L942
|
19,042
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_axisparent_stream
|
def store_axisparent_stream # :nodoc:
store_axisparent(*@config[:axisparent])
store_begin
store_pos(*@config[:axisparent_pos])
store_axis_category_stream
store_axis_values_stream
if !@x_axis_name.nil? || !@x_axis_formula.nil?
store_x_axis_text_stream
end
if !@y_axis_name.nil? || !@y_axis_formula.nil?
store_y_axis_text_stream
end
if @plotarea[:visible] != 0
store_plotarea
store_plotarea_frame_stream
end
store_chartformat_stream
store_end
end
|
ruby
|
def store_axisparent_stream # :nodoc:
store_axisparent(*@config[:axisparent])
store_begin
store_pos(*@config[:axisparent_pos])
store_axis_category_stream
store_axis_values_stream
if !@x_axis_name.nil? || !@x_axis_formula.nil?
store_x_axis_text_stream
end
if !@y_axis_name.nil? || !@y_axis_formula.nil?
store_y_axis_text_stream
end
if @plotarea[:visible] != 0
store_plotarea
store_plotarea_frame_stream
end
store_chartformat_stream
store_end
end
|
[
"def",
"store_axisparent_stream",
"# :nodoc:",
"store_axisparent",
"(",
"@config",
"[",
":axisparent",
"]",
")",
"store_begin",
"store_pos",
"(",
"@config",
"[",
":axisparent_pos",
"]",
")",
"store_axis_category_stream",
"store_axis_values_stream",
"if",
"!",
"@x_axis_name",
".",
"nil?",
"||",
"!",
"@x_axis_formula",
".",
"nil?",
"store_x_axis_text_stream",
"end",
"if",
"!",
"@y_axis_name",
".",
"nil?",
"||",
"!",
"@y_axis_formula",
".",
"nil?",
"store_y_axis_text_stream",
"end",
"if",
"@plotarea",
"[",
":visible",
"]",
"!=",
"0",
"store_plotarea",
"store_plotarea_frame_stream",
"end",
"store_chartformat_stream",
"store_end",
"end"
] |
Write the AXISPARENT chart substream.
|
[
"Write",
"the",
"AXISPARENT",
"chart",
"substream",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1004-L1026
|
19,043
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_ai
|
def store_ai(id, type, formula, format_index = 0) # :nodoc:
formula = '' if formula == [""]
record = 0x1051 # Record identifier.
length = 0x0008 # Number of bytes to follow.
# id # Link index.
# type # Reference type.
# formula # Pre-parsed formula.
# format_index # Num format index.
grbit = 0x0000 # Option flags.
ruby_19 { formula = convert_to_ascii_if_ascii(formula) }
formula_length = formula.bytesize
length += formula_length
header = [record, length].pack('vv')
data = [id].pack('C')
data += [type].pack('C')
data += [grbit].pack('v')
data += [format_index].pack('v')
data += [formula_length].pack('v')
if formula.respond_to?(:to_array)
data +=
ruby_18 { formula[0] } ||
ruby_19 { formula[0].encode('BINARY') }
else
data +=
ruby_18 { formula unless formula.nil? } ||
ruby_19 { formula.encode('BINARY') unless formula.nil? }
end
append(header, data)
end
|
ruby
|
def store_ai(id, type, formula, format_index = 0) # :nodoc:
formula = '' if formula == [""]
record = 0x1051 # Record identifier.
length = 0x0008 # Number of bytes to follow.
# id # Link index.
# type # Reference type.
# formula # Pre-parsed formula.
# format_index # Num format index.
grbit = 0x0000 # Option flags.
ruby_19 { formula = convert_to_ascii_if_ascii(formula) }
formula_length = formula.bytesize
length += formula_length
header = [record, length].pack('vv')
data = [id].pack('C')
data += [type].pack('C')
data += [grbit].pack('v')
data += [format_index].pack('v')
data += [formula_length].pack('v')
if formula.respond_to?(:to_array)
data +=
ruby_18 { formula[0] } ||
ruby_19 { formula[0].encode('BINARY') }
else
data +=
ruby_18 { formula unless formula.nil? } ||
ruby_19 { formula.encode('BINARY') unless formula.nil? }
end
append(header, data)
end
|
[
"def",
"store_ai",
"(",
"id",
",",
"type",
",",
"formula",
",",
"format_index",
"=",
"0",
")",
"# :nodoc:",
"formula",
"=",
"''",
"if",
"formula",
"==",
"[",
"\"\"",
"]",
"record",
"=",
"0x1051",
"# Record identifier.",
"length",
"=",
"0x0008",
"# Number of bytes to follow.",
"# id # Link index.",
"# type # Reference type.",
"# formula # Pre-parsed formula.",
"# format_index # Num format index.",
"grbit",
"=",
"0x0000",
"# Option flags.",
"ruby_19",
"{",
"formula",
"=",
"convert_to_ascii_if_ascii",
"(",
"formula",
")",
"}",
"formula_length",
"=",
"formula",
".",
"bytesize",
"length",
"+=",
"formula_length",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"'vv'",
")",
"data",
"=",
"[",
"id",
"]",
".",
"pack",
"(",
"'C'",
")",
"data",
"+=",
"[",
"type",
"]",
".",
"pack",
"(",
"'C'",
")",
"data",
"+=",
"[",
"grbit",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"format_index",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"formula_length",
"]",
".",
"pack",
"(",
"'v'",
")",
"if",
"formula",
".",
"respond_to?",
"(",
":to_array",
")",
"data",
"+=",
"ruby_18",
"{",
"formula",
"[",
"0",
"]",
"}",
"||",
"ruby_19",
"{",
"formula",
"[",
"0",
"]",
".",
"encode",
"(",
"'BINARY'",
")",
"}",
"else",
"data",
"+=",
"ruby_18",
"{",
"formula",
"unless",
"formula",
".",
"nil?",
"}",
"||",
"ruby_19",
"{",
"formula",
".",
"encode",
"(",
"'BINARY'",
")",
"unless",
"formula",
".",
"nil?",
"}",
"end",
"append",
"(",
"header",
",",
"data",
")",
"end"
] |
Write the AI chart BIFF record.
|
[
"Write",
"the",
"AI",
"chart",
"BIFF",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1171-L1204
|
19,044
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_areaformat
|
def store_areaformat(rgbFore, rgbBack, pattern, grbit, indexFore, indexBack) # :nodoc:
record = 0x100A # Record identifier.
length = 0x0010 # Number of bytes to follow.
# rgbFore # Foreground RGB colour.
# rgbBack # Background RGB colour.
# pattern # Pattern.
# grbit # Option flags.
# indexFore # Index to Foreground colour.
# indexBack # Index to Background colour.
header = [record, length].pack('vv')
data = [rgbFore].pack('V')
data += [rgbBack].pack('V')
data += [pattern].pack('v')
data += [grbit].pack('v')
data += [indexFore].pack('v')
data += [indexBack].pack('v')
append(header, data)
end
|
ruby
|
def store_areaformat(rgbFore, rgbBack, pattern, grbit, indexFore, indexBack) # :nodoc:
record = 0x100A # Record identifier.
length = 0x0010 # Number of bytes to follow.
# rgbFore # Foreground RGB colour.
# rgbBack # Background RGB colour.
# pattern # Pattern.
# grbit # Option flags.
# indexFore # Index to Foreground colour.
# indexBack # Index to Background colour.
header = [record, length].pack('vv')
data = [rgbFore].pack('V')
data += [rgbBack].pack('V')
data += [pattern].pack('v')
data += [grbit].pack('v')
data += [indexFore].pack('v')
data += [indexBack].pack('v')
append(header, data)
end
|
[
"def",
"store_areaformat",
"(",
"rgbFore",
",",
"rgbBack",
",",
"pattern",
",",
"grbit",
",",
"indexFore",
",",
"indexBack",
")",
"# :nodoc:",
"record",
"=",
"0x100A",
"# Record identifier.",
"length",
"=",
"0x0010",
"# Number of bytes to follow.",
"# rgbFore # Foreground RGB colour.",
"# rgbBack # Background RGB colour.",
"# pattern # Pattern.",
"# grbit # Option flags.",
"# indexFore # Index to Foreground colour.",
"# indexBack # Index to Background colour.",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"'vv'",
")",
"data",
"=",
"[",
"rgbFore",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"rgbBack",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"pattern",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"grbit",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"indexFore",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"indexBack",
"]",
".",
"pack",
"(",
"'v'",
")",
"append",
"(",
"header",
",",
"data",
")",
"end"
] |
Write the AREAFORMAT chart BIFF record. Contains the patterns and colours
of a chart area.
|
[
"Write",
"the",
"AREAFORMAT",
"chart",
"BIFF",
"record",
".",
"Contains",
"the",
"patterns",
"and",
"colours",
"of",
"a",
"chart",
"area",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1210-L1229
|
19,045
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_axcext
|
def store_axcext # :nodoc:
record = 0x1062 # Record identifier.
length = 0x0012 # Number of bytes to follow.
catMin = 0x0000 # Minimum category on axis.
catMax = 0x0000 # Maximum category on axis.
catMajor = 0x0001 # Value of major unit.
unitMajor = 0x0000 # Units of major unit.
catMinor = 0x0001 # Value of minor unit.
unitMinor = 0x0000 # Units of minor unit.
unitBase = 0x0000 # Base unit of axis.
catCrossDate = 0x0000 # Crossing point.
grbit = 0x00EF # Option flags.
store_simple(record, length, catMin, catMax, catMajor, unitMajor,
catMinor, unitMinor, unitBase, catCrossDate, grbit)
end
|
ruby
|
def store_axcext # :nodoc:
record = 0x1062 # Record identifier.
length = 0x0012 # Number of bytes to follow.
catMin = 0x0000 # Minimum category on axis.
catMax = 0x0000 # Maximum category on axis.
catMajor = 0x0001 # Value of major unit.
unitMajor = 0x0000 # Units of major unit.
catMinor = 0x0001 # Value of minor unit.
unitMinor = 0x0000 # Units of minor unit.
unitBase = 0x0000 # Base unit of axis.
catCrossDate = 0x0000 # Crossing point.
grbit = 0x00EF # Option flags.
store_simple(record, length, catMin, catMax, catMajor, unitMajor,
catMinor, unitMinor, unitBase, catCrossDate, grbit)
end
|
[
"def",
"store_axcext",
"# :nodoc:",
"record",
"=",
"0x1062",
"# Record identifier.",
"length",
"=",
"0x0012",
"# Number of bytes to follow.",
"catMin",
"=",
"0x0000",
"# Minimum category on axis.",
"catMax",
"=",
"0x0000",
"# Maximum category on axis.",
"catMajor",
"=",
"0x0001",
"# Value of major unit.",
"unitMajor",
"=",
"0x0000",
"# Units of major unit.",
"catMinor",
"=",
"0x0001",
"# Value of minor unit.",
"unitMinor",
"=",
"0x0000",
"# Units of minor unit.",
"unitBase",
"=",
"0x0000",
"# Base unit of axis.",
"catCrossDate",
"=",
"0x0000",
"# Crossing point.",
"grbit",
"=",
"0x00EF",
"# Option flags.",
"store_simple",
"(",
"record",
",",
"length",
",",
"catMin",
",",
"catMax",
",",
"catMajor",
",",
"unitMajor",
",",
"catMinor",
",",
"unitMinor",
",",
"unitBase",
",",
"catCrossDate",
",",
"grbit",
")",
"end"
] |
Write the AXCEXT chart BIFF record.
|
[
"Write",
"the",
"AXCEXT",
"chart",
"BIFF",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1234-L1249
|
19,046
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_axis
|
def store_axis(type) # :nodoc:
record = 0x101D # Record identifier.
length = 0x0012 # Number of bytes to follow.
# type # Axis type.
reserved1 = 0x00000000 # Reserved.
reserved2 = 0x00000000 # Reserved.
reserved3 = 0x00000000 # Reserved.
reserved4 = 0x00000000 # Reserved.
header = [record, length].pack('vv')
data = [type].pack('v')
data += [reserved1].pack('V')
data += [reserved2].pack('V')
data += [reserved3].pack('V')
data += [reserved4].pack('V')
append(header, data)
end
|
ruby
|
def store_axis(type) # :nodoc:
record = 0x101D # Record identifier.
length = 0x0012 # Number of bytes to follow.
# type # Axis type.
reserved1 = 0x00000000 # Reserved.
reserved2 = 0x00000000 # Reserved.
reserved3 = 0x00000000 # Reserved.
reserved4 = 0x00000000 # Reserved.
header = [record, length].pack('vv')
data = [type].pack('v')
data += [reserved1].pack('V')
data += [reserved2].pack('V')
data += [reserved3].pack('V')
data += [reserved4].pack('V')
append(header, data)
end
|
[
"def",
"store_axis",
"(",
"type",
")",
"# :nodoc:",
"record",
"=",
"0x101D",
"# Record identifier.",
"length",
"=",
"0x0012",
"# Number of bytes to follow.",
"# type # Axis type.",
"reserved1",
"=",
"0x00000000",
"# Reserved.",
"reserved2",
"=",
"0x00000000",
"# Reserved.",
"reserved3",
"=",
"0x00000000",
"# Reserved.",
"reserved4",
"=",
"0x00000000",
"# Reserved.",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"'vv'",
")",
"data",
"=",
"[",
"type",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"reserved1",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"reserved2",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"reserved3",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"reserved4",
"]",
".",
"pack",
"(",
"'V'",
")",
"append",
"(",
"header",
",",
"data",
")",
"end"
] |
Write the AXIS chart BIFF record to define the axis type.
|
[
"Write",
"the",
"AXIS",
"chart",
"BIFF",
"record",
"to",
"define",
"the",
"axis",
"type",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1265-L1282
|
19,047
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_axisparent
|
def store_axisparent(iax, x, y, dx, dy) # :nodoc:
record = 0x1041 # Record identifier.
length = 0x0012 # Number of bytes to follow.
# iax # Axis index.
# x # X-coord.
# y # Y-coord.
# dx # Length of x axis.
# dy # Length of y axis.
header = [record, length].pack('vv')
data = [iax].pack('v')
data += [x].pack('V')
data += [y].pack('V')
data += [dx].pack('V')
data += [dy].pack('V')
append(header, data)
end
|
ruby
|
def store_axisparent(iax, x, y, dx, dy) # :nodoc:
record = 0x1041 # Record identifier.
length = 0x0012 # Number of bytes to follow.
# iax # Axis index.
# x # X-coord.
# y # Y-coord.
# dx # Length of x axis.
# dy # Length of y axis.
header = [record, length].pack('vv')
data = [iax].pack('v')
data += [x].pack('V')
data += [y].pack('V')
data += [dx].pack('V')
data += [dy].pack('V')
append(header, data)
end
|
[
"def",
"store_axisparent",
"(",
"iax",
",",
"x",
",",
"y",
",",
"dx",
",",
"dy",
")",
"# :nodoc:",
"record",
"=",
"0x1041",
"# Record identifier.",
"length",
"=",
"0x0012",
"# Number of bytes to follow.",
"# iax # Axis index.",
"# x # X-coord.",
"# y # Y-coord.",
"# dx # Length of x axis.",
"# dy # Length of y axis.",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"'vv'",
")",
"data",
"=",
"[",
"iax",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"x",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"y",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"dx",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"dy",
"]",
".",
"pack",
"(",
"'V'",
")",
"append",
"(",
"header",
",",
"data",
")",
"end"
] |
Write the AXISPARENT chart BIFF record.
|
[
"Write",
"the",
"AXISPARENT",
"chart",
"BIFF",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1298-L1315
|
19,048
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_catserrange
|
def store_catserrange # :nodoc:
record = 0x1020 # Record identifier.
length = 0x0008 # Number of bytes to follow.
catCross = 0x0001 # Value/category crossing.
catLabel = 0x0001 # Frequency of labels.
catMark = 0x0001 # Frequency of ticks.
grbit = 0x0001 # Option flags.
store_simple(record, length, catCross, catLabel, catMark, grbit)
end
|
ruby
|
def store_catserrange # :nodoc:
record = 0x1020 # Record identifier.
length = 0x0008 # Number of bytes to follow.
catCross = 0x0001 # Value/category crossing.
catLabel = 0x0001 # Frequency of labels.
catMark = 0x0001 # Frequency of ticks.
grbit = 0x0001 # Option flags.
store_simple(record, length, catCross, catLabel, catMark, grbit)
end
|
[
"def",
"store_catserrange",
"# :nodoc:",
"record",
"=",
"0x1020",
"# Record identifier.",
"length",
"=",
"0x0008",
"# Number of bytes to follow.",
"catCross",
"=",
"0x0001",
"# Value/category crossing.",
"catLabel",
"=",
"0x0001",
"# Frequency of labels.",
"catMark",
"=",
"0x0001",
"# Frequency of ticks.",
"grbit",
"=",
"0x0001",
"# Option flags.",
"store_simple",
"(",
"record",
",",
"length",
",",
"catCross",
",",
"catLabel",
",",
"catMark",
",",
"grbit",
")",
"end"
] |
Write the CATSERRANGE chart BIFF record.
|
[
"Write",
"the",
"CATSERRANGE",
"chart",
"BIFF",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1330-L1339
|
19,049
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_chartformat
|
def store_chartformat(grbit = 0) # :nodoc:
record = 0x1014 # Record identifier.
length = 0x0014 # Number of bytes to follow.
reserved1 = 0x00000000 # Reserved.
reserved2 = 0x00000000 # Reserved.
reserved3 = 0x00000000 # Reserved.
reserved4 = 0x00000000 # Reserved.
# grbit # Option flags.
icrt = 0x0000 # Drawing order.
header = [record, length].pack('vv')
data = [reserved1].pack('V')
data += [reserved2].pack('V')
data += [reserved3].pack('V')
data += [reserved4].pack('V')
data += [grbit].pack('v')
data += [icrt].pack('v')
append(header, data)
end
|
ruby
|
def store_chartformat(grbit = 0) # :nodoc:
record = 0x1014 # Record identifier.
length = 0x0014 # Number of bytes to follow.
reserved1 = 0x00000000 # Reserved.
reserved2 = 0x00000000 # Reserved.
reserved3 = 0x00000000 # Reserved.
reserved4 = 0x00000000 # Reserved.
# grbit # Option flags.
icrt = 0x0000 # Drawing order.
header = [record, length].pack('vv')
data = [reserved1].pack('V')
data += [reserved2].pack('V')
data += [reserved3].pack('V')
data += [reserved4].pack('V')
data += [grbit].pack('v')
data += [icrt].pack('v')
append(header, data)
end
|
[
"def",
"store_chartformat",
"(",
"grbit",
"=",
"0",
")",
"# :nodoc:",
"record",
"=",
"0x1014",
"# Record identifier.",
"length",
"=",
"0x0014",
"# Number of bytes to follow.",
"reserved1",
"=",
"0x00000000",
"# Reserved.",
"reserved2",
"=",
"0x00000000",
"# Reserved.",
"reserved3",
"=",
"0x00000000",
"# Reserved.",
"reserved4",
"=",
"0x00000000",
"# Reserved.",
"# grbit # Option flags.",
"icrt",
"=",
"0x0000",
"# Drawing order.",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"'vv'",
")",
"data",
"=",
"[",
"reserved1",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"reserved2",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"reserved3",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"reserved4",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"grbit",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"icrt",
"]",
".",
"pack",
"(",
"'v'",
")",
"append",
"(",
"header",
",",
"data",
")",
"end"
] |
Write the CHARTFORMAT chart BIFF record. The parent record for formatting
of a chart group.
|
[
"Write",
"the",
"CHARTFORMAT",
"chart",
"BIFF",
"record",
".",
"The",
"parent",
"record",
"for",
"formatting",
"of",
"a",
"chart",
"group",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1367-L1386
|
19,050
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_dataformat
|
def store_dataformat(series_index, series_number, point_number) # :nodoc:
record = 0x1006 # Record identifier.
length = 0x0008 # Number of bytes to follow.
# series_index # Series index.
# series_number # Series number. (Same as index).
# point_number # Point number.
grbit = 0x0000 # Format flags.
store_simple(record, length, point_number, series_index, series_number, grbit)
end
|
ruby
|
def store_dataformat(series_index, series_number, point_number) # :nodoc:
record = 0x1006 # Record identifier.
length = 0x0008 # Number of bytes to follow.
# series_index # Series index.
# series_number # Series number. (Same as index).
# point_number # Point number.
grbit = 0x0000 # Format flags.
store_simple(record, length, point_number, series_index, series_number, grbit)
end
|
[
"def",
"store_dataformat",
"(",
"series_index",
",",
"series_number",
",",
"point_number",
")",
"# :nodoc:",
"record",
"=",
"0x1006",
"# Record identifier.",
"length",
"=",
"0x0008",
"# Number of bytes to follow.",
"# series_index # Series index.",
"# series_number # Series number. (Same as index).",
"# point_number # Point number.",
"grbit",
"=",
"0x0000",
"# Format flags.",
"store_simple",
"(",
"record",
",",
"length",
",",
"point_number",
",",
"series_index",
",",
"series_number",
",",
"grbit",
")",
"end"
] |
Write the DATAFORMAT chart BIFF record. This record specifies the series
that the subsequent sub stream refers to.
|
[
"Write",
"the",
"DATAFORMAT",
"chart",
"BIFF",
"record",
".",
"This",
"record",
"specifies",
"the",
"series",
"that",
"the",
"subsequent",
"sub",
"stream",
"refers",
"to",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1439-L1448
|
19,051
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_fbi
|
def store_fbi(index, height, width_basis, height_basis, scale_basis) # :nodoc:
record = 0x1060 # Record identifier.
length = 0x000A # Number of bytes to follow.
# index # Font index.
height = height * 20 # Default font height in twips.
# width_basis # Width basis, in twips.
# height_basis # Height basis, in twips.
# scale_basis # Scale by chart area or plot area.
store_simple(record, length, width_basis, height_basis, height, scale_basis, index)
end
|
ruby
|
def store_fbi(index, height, width_basis, height_basis, scale_basis) # :nodoc:
record = 0x1060 # Record identifier.
length = 0x000A # Number of bytes to follow.
# index # Font index.
height = height * 20 # Default font height in twips.
# width_basis # Width basis, in twips.
# height_basis # Height basis, in twips.
# scale_basis # Scale by chart area or plot area.
store_simple(record, length, width_basis, height_basis, height, scale_basis, index)
end
|
[
"def",
"store_fbi",
"(",
"index",
",",
"height",
",",
"width_basis",
",",
"height_basis",
",",
"scale_basis",
")",
"# :nodoc:",
"record",
"=",
"0x1060",
"# Record identifier.",
"length",
"=",
"0x000A",
"# Number of bytes to follow.",
"# index # Font index.",
"height",
"=",
"height",
"*",
"20",
"# Default font height in twips.",
"# width_basis # Width basis, in twips.",
"# height_basis # Height basis, in twips.",
"# scale_basis # Scale by chart area or plot area.",
"store_simple",
"(",
"record",
",",
"length",
",",
"width_basis",
",",
"height_basis",
",",
"height",
",",
"scale_basis",
",",
"index",
")",
"end"
] |
Write the FBI chart BIFF record. Specifies the font information at the time
it was applied to the chart.
|
[
"Write",
"the",
"FBI",
"chart",
"BIFF",
"record",
".",
"Specifies",
"the",
"font",
"information",
"at",
"the",
"time",
"it",
"was",
"applied",
"to",
"the",
"chart",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1487-L1497
|
19,052
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_frame
|
def store_frame(frame_type, grbit) # :nodoc:
record = 0x1032 # Record identifier.
length = 0x0004 # Number of bytes to follow.
# frame_type # Frame type.
# grbit # Option flags.
store_simple(record, length, frame_type, grbit)
end
|
ruby
|
def store_frame(frame_type, grbit) # :nodoc:
record = 0x1032 # Record identifier.
length = 0x0004 # Number of bytes to follow.
# frame_type # Frame type.
# grbit # Option flags.
store_simple(record, length, frame_type, grbit)
end
|
[
"def",
"store_frame",
"(",
"frame_type",
",",
"grbit",
")",
"# :nodoc:",
"record",
"=",
"0x1032",
"# Record identifier.",
"length",
"=",
"0x0004",
"# Number of bytes to follow.",
"# frame_type # Frame type.",
"# grbit # Option flags.",
"store_simple",
"(",
"record",
",",
"length",
",",
"frame_type",
",",
"grbit",
")",
"end"
] |
Write the FRAME chart BIFF record.
|
[
"Write",
"the",
"FRAME",
"chart",
"BIFF",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1514-L1521
|
19,053
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_legend
|
def store_legend(x, y, width, height, wType, wSpacing, grbit) # :nodoc:
record = 0x1015 # Record identifier.
length = 0x0014 # Number of bytes to follow.
# x # X-position.
# y # Y-position.
# width # Width.
# height # Height.
# wType # Type.
# wSpacing # Spacing.
# grbit # Option flags.
header = [record, length].pack('vv')
data = [x].pack('V')
data += [y].pack('V')
data += [width].pack('V')
data += [height].pack('V')
data += [wType].pack('C')
data += [wSpacing].pack('C')
data += [grbit].pack('v')
append(header, data)
end
|
ruby
|
def store_legend(x, y, width, height, wType, wSpacing, grbit) # :nodoc:
record = 0x1015 # Record identifier.
length = 0x0014 # Number of bytes to follow.
# x # X-position.
# y # Y-position.
# width # Width.
# height # Height.
# wType # Type.
# wSpacing # Spacing.
# grbit # Option flags.
header = [record, length].pack('vv')
data = [x].pack('V')
data += [y].pack('V')
data += [width].pack('V')
data += [height].pack('V')
data += [wType].pack('C')
data += [wSpacing].pack('C')
data += [grbit].pack('v')
append(header, data)
end
|
[
"def",
"store_legend",
"(",
"x",
",",
"y",
",",
"width",
",",
"height",
",",
"wType",
",",
"wSpacing",
",",
"grbit",
")",
"# :nodoc:",
"record",
"=",
"0x1015",
"# Record identifier.",
"length",
"=",
"0x0014",
"# Number of bytes to follow.",
"# x # X-position.",
"# y # Y-position.",
"# width # Width.",
"# height # Height.",
"# wType # Type.",
"# wSpacing # Spacing.",
"# grbit # Option flags.",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"'vv'",
")",
"data",
"=",
"[",
"x",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"y",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"width",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"height",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"wType",
"]",
".",
"pack",
"(",
"'C'",
")",
"data",
"+=",
"[",
"wSpacing",
"]",
".",
"pack",
"(",
"'C'",
")",
"data",
"+=",
"[",
"grbit",
"]",
".",
"pack",
"(",
"'v'",
")",
"append",
"(",
"header",
",",
"data",
")",
"end"
] |
Write the LEGEND chart BIFF record. The Marcus Horan method.
|
[
"Write",
"the",
"LEGEND",
"chart",
"BIFF",
"record",
".",
"The",
"Marcus",
"Horan",
"method",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1526-L1547
|
19,054
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_lineformat
|
def store_lineformat(rgb, lns, we, grbit, index) # :nodoc:
record = 0x1007 # Record identifier.
length = 0x000C # Number of bytes to follow.
# rgb # Line RGB colour.
# lns # Line pattern.
# we # Line weight.
# grbit # Option flags.
# index # Index to colour of line.
header = [record, length].pack('vv')
data = [rgb].pack('V')
data += [lns].pack('v')
data += [we].pack('v')
data += [grbit].pack('v')
data += [index].pack('v')
append(header, data)
end
|
ruby
|
def store_lineformat(rgb, lns, we, grbit, index) # :nodoc:
record = 0x1007 # Record identifier.
length = 0x000C # Number of bytes to follow.
# rgb # Line RGB colour.
# lns # Line pattern.
# we # Line weight.
# grbit # Option flags.
# index # Index to colour of line.
header = [record, length].pack('vv')
data = [rgb].pack('V')
data += [lns].pack('v')
data += [we].pack('v')
data += [grbit].pack('v')
data += [index].pack('v')
append(header, data)
end
|
[
"def",
"store_lineformat",
"(",
"rgb",
",",
"lns",
",",
"we",
",",
"grbit",
",",
"index",
")",
"# :nodoc:",
"record",
"=",
"0x1007",
"# Record identifier.",
"length",
"=",
"0x000C",
"# Number of bytes to follow.",
"# rgb # Line RGB colour.",
"# lns # Line pattern.",
"# we # Line weight.",
"# grbit # Option flags.",
"# index # Index to colour of line.",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"'vv'",
")",
"data",
"=",
"[",
"rgb",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"lns",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"we",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"grbit",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"index",
"]",
".",
"pack",
"(",
"'v'",
")",
"append",
"(",
"header",
",",
"data",
")",
"end"
] |
Write the LINEFORMAT chart BIFF record.
|
[
"Write",
"the",
"LINEFORMAT",
"chart",
"BIFF",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1552-L1569
|
19,055
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_markerformat
|
def store_markerformat(rgbFore, rgbBack, marker, grbit, icvFore, icvBack, miSize)# :nodoc:
record = 0x1009 # Record identifier.
length = 0x0014 # Number of bytes to follow.
# rgbFore # Foreground RGB color.
# rgbBack # Background RGB color.
# marker # Type of marker.
# grbit # Format flags.
# icvFore # Color index marker border.
# icvBack # Color index marker fill.
# miSize # Size of line markers.
header = [record, length].pack('vv')
data = [rgbFore].pack('V')
data += [rgbBack].pack('V')
data += [marker].pack('v')
data += [grbit].pack('v')
data += [icvFore].pack('v')
data += [icvBack].pack('v')
data += [miSize].pack('V')
append(header, data)
end
|
ruby
|
def store_markerformat(rgbFore, rgbBack, marker, grbit, icvFore, icvBack, miSize)# :nodoc:
record = 0x1009 # Record identifier.
length = 0x0014 # Number of bytes to follow.
# rgbFore # Foreground RGB color.
# rgbBack # Background RGB color.
# marker # Type of marker.
# grbit # Format flags.
# icvFore # Color index marker border.
# icvBack # Color index marker fill.
# miSize # Size of line markers.
header = [record, length].pack('vv')
data = [rgbFore].pack('V')
data += [rgbBack].pack('V')
data += [marker].pack('v')
data += [grbit].pack('v')
data += [icvFore].pack('v')
data += [icvBack].pack('v')
data += [miSize].pack('V')
append(header, data)
end
|
[
"def",
"store_markerformat",
"(",
"rgbFore",
",",
"rgbBack",
",",
"marker",
",",
"grbit",
",",
"icvFore",
",",
"icvBack",
",",
"miSize",
")",
"# :nodoc:",
"record",
"=",
"0x1009",
"# Record identifier.",
"length",
"=",
"0x0014",
"# Number of bytes to follow.",
"# rgbFore # Foreground RGB color.",
"# rgbBack # Background RGB color.",
"# marker # Type of marker.",
"# grbit # Format flags.",
"# icvFore # Color index marker border.",
"# icvBack # Color index marker fill.",
"# miSize # Size of line markers.",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"'vv'",
")",
"data",
"=",
"[",
"rgbFore",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"rgbBack",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"marker",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"grbit",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"icvFore",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"icvBack",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"miSize",
"]",
".",
"pack",
"(",
"'V'",
")",
"append",
"(",
"header",
",",
"data",
")",
"end"
] |
Write the MARKERFORMAT chart BIFF record.
|
[
"Write",
"the",
"MARKERFORMAT",
"chart",
"BIFF",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1574-L1595
|
19,056
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_objectlink
|
def store_objectlink(link_type) # :nodoc:
record = 0x1027 # Record identifier.
length = 0x0006 # Number of bytes to follow.
# link_type # Object text link type.
link_index1 = 0x0000 # Link index 1.
link_index2 = 0x0000 # Link index 2.
store_simple(record, length, link_type, link_index1, link_index2)
end
|
ruby
|
def store_objectlink(link_type) # :nodoc:
record = 0x1027 # Record identifier.
length = 0x0006 # Number of bytes to follow.
# link_type # Object text link type.
link_index1 = 0x0000 # Link index 1.
link_index2 = 0x0000 # Link index 2.
store_simple(record, length, link_type, link_index1, link_index2)
end
|
[
"def",
"store_objectlink",
"(",
"link_type",
")",
"# :nodoc:",
"record",
"=",
"0x1027",
"# Record identifier.",
"length",
"=",
"0x0006",
"# Number of bytes to follow.",
"# link_type # Object text link type.",
"link_index1",
"=",
"0x0000",
"# Link index 1.",
"link_index2",
"=",
"0x0000",
"# Link index 2.",
"store_simple",
"(",
"record",
",",
"length",
",",
"link_type",
",",
"link_index1",
",",
"link_index2",
")",
"end"
] |
Write the OBJECTLINK chart BIFF record.
|
[
"Write",
"the",
"OBJECTLINK",
"chart",
"BIFF",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1600-L1608
|
19,057
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_plotgrowth
|
def store_plotgrowth # :nodoc:
record = 0x1064 # Record identifier.
length = 0x0008 # Number of bytes to follow.
dx_plot = 0x00010000 # Horz growth for font scale.
dy_plot = 0x00010000 # Vert growth for font scale.
header = [record, length].pack('vv')
data = [dx_plot].pack('V')
data += [dy_plot].pack('V')
append(header, data)
end
|
ruby
|
def store_plotgrowth # :nodoc:
record = 0x1064 # Record identifier.
length = 0x0008 # Number of bytes to follow.
dx_plot = 0x00010000 # Horz growth for font scale.
dy_plot = 0x00010000 # Vert growth for font scale.
header = [record, length].pack('vv')
data = [dx_plot].pack('V')
data += [dy_plot].pack('V')
append(header, data)
end
|
[
"def",
"store_plotgrowth",
"# :nodoc:",
"record",
"=",
"0x1064",
"# Record identifier.",
"length",
"=",
"0x0008",
"# Number of bytes to follow.",
"dx_plot",
"=",
"0x00010000",
"# Horz growth for font scale.",
"dy_plot",
"=",
"0x00010000",
"# Vert growth for font scale.",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"'vv'",
")",
"data",
"=",
"[",
"dx_plot",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"dy_plot",
"]",
".",
"pack",
"(",
"'V'",
")",
"append",
"(",
"header",
",",
"data",
")",
"end"
] |
Write the PLOTGROWTH chart BIFF record.
|
[
"Write",
"the",
"PLOTGROWTH",
"chart",
"BIFF",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1635-L1646
|
19,058
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_pos
|
def store_pos(mdTopLt, mdBotRt, x1, y1, x2, y2) # :nodoc:
record = 0x104F # Record identifier.
length = 0x0014 # Number of bytes to follow.
# mdTopLt # Top left.
# mdBotRt # Bottom right.
# x1 # X coordinate.
# y1 # Y coordinate.
# x2 # Width.
# y2 # Height.
header = [record, length].pack('vv')
data = [mdTopLt].pack('v')
data += [mdBotRt].pack('v')
data += [x1].pack('V')
data += [y1].pack('V')
data += [x2].pack('V')
data += [y2].pack('V')
append(header, data)
end
|
ruby
|
def store_pos(mdTopLt, mdBotRt, x1, y1, x2, y2) # :nodoc:
record = 0x104F # Record identifier.
length = 0x0014 # Number of bytes to follow.
# mdTopLt # Top left.
# mdBotRt # Bottom right.
# x1 # X coordinate.
# y1 # Y coordinate.
# x2 # Width.
# y2 # Height.
header = [record, length].pack('vv')
data = [mdTopLt].pack('v')
data += [mdBotRt].pack('v')
data += [x1].pack('V')
data += [y1].pack('V')
data += [x2].pack('V')
data += [y2].pack('V')
append(header, data)
end
|
[
"def",
"store_pos",
"(",
"mdTopLt",
",",
"mdBotRt",
",",
"x1",
",",
"y1",
",",
"x2",
",",
"y2",
")",
"# :nodoc:",
"record",
"=",
"0x104F",
"# Record identifier.",
"length",
"=",
"0x0014",
"# Number of bytes to follow.",
"# mdTopLt # Top left.",
"# mdBotRt # Bottom right.",
"# x1 # X coordinate.",
"# y1 # Y coordinate.",
"# x2 # Width.",
"# y2 # Height.",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"'vv'",
")",
"data",
"=",
"[",
"mdTopLt",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"mdBotRt",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"x1",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"y1",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"x2",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"y2",
"]",
".",
"pack",
"(",
"'V'",
")",
"append",
"(",
"header",
",",
"data",
")",
"end"
] |
Write the POS chart BIFF record. Generally not required when using
automatic positioning.
|
[
"Write",
"the",
"POS",
"chart",
"BIFF",
"record",
".",
"Generally",
"not",
"required",
"when",
"using",
"automatic",
"positioning",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1652-L1671
|
19,059
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_serauxtrend
|
def store_serauxtrend(reg_type, poly_order, equation, r_squared) # :nodoc:
record = 0x104B # Record identifier.
length = 0x001C # Number of bytes to follow.
# reg_type # Regression type.
# poly_order # Polynomial order.
# equation # Display equation.
# r_squared # Display R-squared.
# intercept # Forced intercept.
# forecast # Forecast forward.
# backcast # Forecast backward.
# TODO. When supported, intercept needs to be NAN if not used.
# Also need to reverse doubles.
intercept = ['FFFFFFFF0001FFFF'].pack('H*')
forecast = ['0000000000000000'].pack('H*')
backcast = ['0000000000000000'].pack('H*')
header = [record, length].pack('vv')
data = [reg_type].pack('C')
data += [poly_order].pack('C')
data += intercept
data += [equation].pack('C')
data += [r_squared].pack('C')
data += forecast
data += backcast
append(header, data)
end
|
ruby
|
def store_serauxtrend(reg_type, poly_order, equation, r_squared) # :nodoc:
record = 0x104B # Record identifier.
length = 0x001C # Number of bytes to follow.
# reg_type # Regression type.
# poly_order # Polynomial order.
# equation # Display equation.
# r_squared # Display R-squared.
# intercept # Forced intercept.
# forecast # Forecast forward.
# backcast # Forecast backward.
# TODO. When supported, intercept needs to be NAN if not used.
# Also need to reverse doubles.
intercept = ['FFFFFFFF0001FFFF'].pack('H*')
forecast = ['0000000000000000'].pack('H*')
backcast = ['0000000000000000'].pack('H*')
header = [record, length].pack('vv')
data = [reg_type].pack('C')
data += [poly_order].pack('C')
data += intercept
data += [equation].pack('C')
data += [r_squared].pack('C')
data += forecast
data += backcast
append(header, data)
end
|
[
"def",
"store_serauxtrend",
"(",
"reg_type",
",",
"poly_order",
",",
"equation",
",",
"r_squared",
")",
"# :nodoc:",
"record",
"=",
"0x104B",
"# Record identifier.",
"length",
"=",
"0x001C",
"# Number of bytes to follow.",
"# reg_type # Regression type.",
"# poly_order # Polynomial order.",
"# equation # Display equation.",
"# r_squared # Display R-squared.",
"# intercept # Forced intercept.",
"# forecast # Forecast forward.",
"# backcast # Forecast backward.",
"# TODO. When supported, intercept needs to be NAN if not used.",
"# Also need to reverse doubles.",
"intercept",
"=",
"[",
"'FFFFFFFF0001FFFF'",
"]",
".",
"pack",
"(",
"'H*'",
")",
"forecast",
"=",
"[",
"'0000000000000000'",
"]",
".",
"pack",
"(",
"'H*'",
")",
"backcast",
"=",
"[",
"'0000000000000000'",
"]",
".",
"pack",
"(",
"'H*'",
")",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"'vv'",
")",
"data",
"=",
"[",
"reg_type",
"]",
".",
"pack",
"(",
"'C'",
")",
"data",
"+=",
"[",
"poly_order",
"]",
".",
"pack",
"(",
"'C'",
")",
"data",
"+=",
"intercept",
"data",
"+=",
"[",
"equation",
"]",
".",
"pack",
"(",
"'C'",
")",
"data",
"+=",
"[",
"r_squared",
"]",
".",
"pack",
"(",
"'C'",
")",
"data",
"+=",
"forecast",
"data",
"+=",
"backcast",
"append",
"(",
"header",
",",
"data",
")",
"end"
] |
Write the SERAUXTREND chart BIFF record.
|
[
"Write",
"the",
"SERAUXTREND",
"chart",
"BIFF",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1676-L1703
|
19,060
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_series
|
def store_series(category_count, value_count) # :nodoc:
record = 0x1003 # Record identifier.
length = 0x000C # Number of bytes to follow.
category_type = 0x0001 # Type: category.
value_type = 0x0001 # Type: value.
# category_count # Num of categories.
# value_count # Num of values.
bubble_type = 0x0001 # Type: bubble.
bubble_count = 0x0000 # Num of bubble values.
store_simple(record, length, category_type, value_type,
category_count, value_count, bubble_type, bubble_count)
end
|
ruby
|
def store_series(category_count, value_count) # :nodoc:
record = 0x1003 # Record identifier.
length = 0x000C # Number of bytes to follow.
category_type = 0x0001 # Type: category.
value_type = 0x0001 # Type: value.
# category_count # Num of categories.
# value_count # Num of values.
bubble_type = 0x0001 # Type: bubble.
bubble_count = 0x0000 # Num of bubble values.
store_simple(record, length, category_type, value_type,
category_count, value_count, bubble_type, bubble_count)
end
|
[
"def",
"store_series",
"(",
"category_count",
",",
"value_count",
")",
"# :nodoc:",
"record",
"=",
"0x1003",
"# Record identifier.",
"length",
"=",
"0x000C",
"# Number of bytes to follow.",
"category_type",
"=",
"0x0001",
"# Type: category.",
"value_type",
"=",
"0x0001",
"# Type: value.",
"# category_count # Num of categories.",
"# value_count # Num of values.",
"bubble_type",
"=",
"0x0001",
"# Type: bubble.",
"bubble_count",
"=",
"0x0000",
"# Num of bubble values.",
"store_simple",
"(",
"record",
",",
"length",
",",
"category_type",
",",
"value_type",
",",
"category_count",
",",
"value_count",
",",
"bubble_type",
",",
"bubble_count",
")",
"end"
] |
Write the SERIES chart BIFF record.
|
[
"Write",
"the",
"SERIES",
"chart",
"BIFF",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1708-L1720
|
19,061
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_seriestext
|
def store_seriestext(str, encoding) # :nodoc:
ruby_19 { str = convert_to_ascii_if_ascii(str) }
record = 0x100D # Record identifier.
length = 0x0000 # Number of bytes to follow.
id = 0x0000 # Text id.
# str # Text.
# encoding # String encoding.
cch = str.bytesize # String length.
encoding ||= 0
# Character length is num of chars not num of bytes
cch /= 2 if encoding != 0
# Change the UTF-16 name from BE to LE
str = str.unpack('v*').pack('n*') if encoding != 0
length = 4 + str.bytesize
header = [record, length].pack('vv')
data = [id].pack('v')
data += [cch].pack('C')
data += [encoding].pack('C')
append(header, data, str)
end
|
ruby
|
def store_seriestext(str, encoding) # :nodoc:
ruby_19 { str = convert_to_ascii_if_ascii(str) }
record = 0x100D # Record identifier.
length = 0x0000 # Number of bytes to follow.
id = 0x0000 # Text id.
# str # Text.
# encoding # String encoding.
cch = str.bytesize # String length.
encoding ||= 0
# Character length is num of chars not num of bytes
cch /= 2 if encoding != 0
# Change the UTF-16 name from BE to LE
str = str.unpack('v*').pack('n*') if encoding != 0
length = 4 + str.bytesize
header = [record, length].pack('vv')
data = [id].pack('v')
data += [cch].pack('C')
data += [encoding].pack('C')
append(header, data, str)
end
|
[
"def",
"store_seriestext",
"(",
"str",
",",
"encoding",
")",
"# :nodoc:",
"ruby_19",
"{",
"str",
"=",
"convert_to_ascii_if_ascii",
"(",
"str",
")",
"}",
"record",
"=",
"0x100D",
"# Record identifier.",
"length",
"=",
"0x0000",
"# Number of bytes to follow.",
"id",
"=",
"0x0000",
"# Text id.",
"# str # Text.",
"# encoding # String encoding.",
"cch",
"=",
"str",
".",
"bytesize",
"# String length.",
"encoding",
"||=",
"0",
"# Character length is num of chars not num of bytes",
"cch",
"/=",
"2",
"if",
"encoding",
"!=",
"0",
"# Change the UTF-16 name from BE to LE",
"str",
"=",
"str",
".",
"unpack",
"(",
"'v*'",
")",
".",
"pack",
"(",
"'n*'",
")",
"if",
"encoding",
"!=",
"0",
"length",
"=",
"4",
"+",
"str",
".",
"bytesize",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"'vv'",
")",
"data",
"=",
"[",
"id",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"cch",
"]",
".",
"pack",
"(",
"'C'",
")",
"data",
"+=",
"[",
"encoding",
"]",
".",
"pack",
"(",
"'C'",
")",
"append",
"(",
"header",
",",
"data",
",",
"str",
")",
"end"
] |
Write the SERIESTEXT chart BIFF record.
|
[
"Write",
"the",
"SERIESTEXT",
"chart",
"BIFF",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1725-L1751
|
19,062
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_shtprops
|
def store_shtprops # :nodoc:
record = 0x1044 # Record identifier.
length = 0x0004 # Number of bytes to follow.
grbit = 0x000E # Option flags.
empty_cells = 0x0000 # Empty cell handling.
grbit = 0x000A if @embedded
store_simple(record, length, grbit, empty_cells)
end
|
ruby
|
def store_shtprops # :nodoc:
record = 0x1044 # Record identifier.
length = 0x0004 # Number of bytes to follow.
grbit = 0x000E # Option flags.
empty_cells = 0x0000 # Empty cell handling.
grbit = 0x000A if @embedded
store_simple(record, length, grbit, empty_cells)
end
|
[
"def",
"store_shtprops",
"# :nodoc:",
"record",
"=",
"0x1044",
"# Record identifier.",
"length",
"=",
"0x0004",
"# Number of bytes to follow.",
"grbit",
"=",
"0x000E",
"# Option flags.",
"empty_cells",
"=",
"0x0000",
"# Empty cell handling.",
"grbit",
"=",
"0x000A",
"if",
"@embedded",
"store_simple",
"(",
"record",
",",
"length",
",",
"grbit",
",",
"empty_cells",
")",
"end"
] |
Write the SHTPROPS chart BIFF record.
|
[
"Write",
"the",
"SHTPROPS",
"chart",
"BIFF",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1778-L1787
|
19,063
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_tick
|
def store_tick # :nodoc:
record = 0x101E # Record identifier.
length = 0x001E # Number of bytes to follow.
tktMajor = 0x02 # Type of major tick mark.
tktMinor = 0x00 # Type of minor tick mark.
tlt = 0x03 # Tick label position.
wBkgMode = 0x01 # Background mode.
rgb = 0x00000000 # Tick-label RGB colour.
reserved1 = 0x00000000 # Reserved.
reserved2 = 0x00000000 # Reserved.
reserved3 = 0x00000000 # Reserved.
reserved4 = 0x00000000 # Reserved.
grbit = 0x0023 # Option flags.
index = 0x004D # Colour index.
reserved5 = 0x0000 # Reserved.
header = [record, length].pack('vv')
data = [tktMajor].pack('C')
data += [tktMinor].pack('C')
data += [tlt].pack('C')
data += [wBkgMode].pack('C')
data += [rgb].pack('V')
data += [reserved1].pack('V')
data += [reserved2].pack('V')
data += [reserved3].pack('V')
data += [reserved4].pack('V')
data += [grbit].pack('v')
data += [index].pack('v')
data += [reserved5].pack('v')
append(header, data)
end
|
ruby
|
def store_tick # :nodoc:
record = 0x101E # Record identifier.
length = 0x001E # Number of bytes to follow.
tktMajor = 0x02 # Type of major tick mark.
tktMinor = 0x00 # Type of minor tick mark.
tlt = 0x03 # Tick label position.
wBkgMode = 0x01 # Background mode.
rgb = 0x00000000 # Tick-label RGB colour.
reserved1 = 0x00000000 # Reserved.
reserved2 = 0x00000000 # Reserved.
reserved3 = 0x00000000 # Reserved.
reserved4 = 0x00000000 # Reserved.
grbit = 0x0023 # Option flags.
index = 0x004D # Colour index.
reserved5 = 0x0000 # Reserved.
header = [record, length].pack('vv')
data = [tktMajor].pack('C')
data += [tktMinor].pack('C')
data += [tlt].pack('C')
data += [wBkgMode].pack('C')
data += [rgb].pack('V')
data += [reserved1].pack('V')
data += [reserved2].pack('V')
data += [reserved3].pack('V')
data += [reserved4].pack('V')
data += [grbit].pack('v')
data += [index].pack('v')
data += [reserved5].pack('v')
append(header, data)
end
|
[
"def",
"store_tick",
"# :nodoc:",
"record",
"=",
"0x101E",
"# Record identifier.",
"length",
"=",
"0x001E",
"# Number of bytes to follow.",
"tktMajor",
"=",
"0x02",
"# Type of major tick mark.",
"tktMinor",
"=",
"0x00",
"# Type of minor tick mark.",
"tlt",
"=",
"0x03",
"# Tick label position.",
"wBkgMode",
"=",
"0x01",
"# Background mode.",
"rgb",
"=",
"0x00000000",
"# Tick-label RGB colour.",
"reserved1",
"=",
"0x00000000",
"# Reserved.",
"reserved2",
"=",
"0x00000000",
"# Reserved.",
"reserved3",
"=",
"0x00000000",
"# Reserved.",
"reserved4",
"=",
"0x00000000",
"# Reserved.",
"grbit",
"=",
"0x0023",
"# Option flags.",
"index",
"=",
"0x004D",
"# Colour index.",
"reserved5",
"=",
"0x0000",
"# Reserved.",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"'vv'",
")",
"data",
"=",
"[",
"tktMajor",
"]",
".",
"pack",
"(",
"'C'",
")",
"data",
"+=",
"[",
"tktMinor",
"]",
".",
"pack",
"(",
"'C'",
")",
"data",
"+=",
"[",
"tlt",
"]",
".",
"pack",
"(",
"'C'",
")",
"data",
"+=",
"[",
"wBkgMode",
"]",
".",
"pack",
"(",
"'C'",
")",
"data",
"+=",
"[",
"rgb",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"reserved1",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"reserved2",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"reserved3",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"reserved4",
"]",
".",
"pack",
"(",
"'V'",
")",
"data",
"+=",
"[",
"grbit",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"index",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"reserved5",
"]",
".",
"pack",
"(",
"'v'",
")",
"append",
"(",
"header",
",",
"data",
")",
"end"
] |
Write the TICK chart BIFF record.
|
[
"Write",
"the",
"TICK",
"chart",
"BIFF",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1828-L1859
|
19,064
|
cxn03651/writeexcel
|
lib/writeexcel/chart.rb
|
Writeexcel.Chart.store_valuerange
|
def store_valuerange # :nodoc:
record = 0x101F # Record identifier.
length = 0x002A # Number of bytes to follow.
numMin = 0x00000000 # Minimum value on axis.
numMax = 0x00000000 # Maximum value on axis.
numMajor = 0x00000000 # Value of major increment.
numMinor = 0x00000000 # Value of minor increment.
numCross = 0x00000000 # Value where category axis crosses.
grbit = 0x011F # Format flags.
# TODO. Reverse doubles when they are handled.
header = [record, length].pack('vv')
data = [numMin].pack('d')
data += [numMax].pack('d')
data += [numMajor].pack('d')
data += [numMinor].pack('d')
data += [numCross].pack('d')
data += [grbit].pack('v')
append(header, data)
end
|
ruby
|
def store_valuerange # :nodoc:
record = 0x101F # Record identifier.
length = 0x002A # Number of bytes to follow.
numMin = 0x00000000 # Minimum value on axis.
numMax = 0x00000000 # Maximum value on axis.
numMajor = 0x00000000 # Value of major increment.
numMinor = 0x00000000 # Value of minor increment.
numCross = 0x00000000 # Value where category axis crosses.
grbit = 0x011F # Format flags.
# TODO. Reverse doubles when they are handled.
header = [record, length].pack('vv')
data = [numMin].pack('d')
data += [numMax].pack('d')
data += [numMajor].pack('d')
data += [numMinor].pack('d')
data += [numCross].pack('d')
data += [grbit].pack('v')
append(header, data)
end
|
[
"def",
"store_valuerange",
"# :nodoc:",
"record",
"=",
"0x101F",
"# Record identifier.",
"length",
"=",
"0x002A",
"# Number of bytes to follow.",
"numMin",
"=",
"0x00000000",
"# Minimum value on axis.",
"numMax",
"=",
"0x00000000",
"# Maximum value on axis.",
"numMajor",
"=",
"0x00000000",
"# Value of major increment.",
"numMinor",
"=",
"0x00000000",
"# Value of minor increment.",
"numCross",
"=",
"0x00000000",
"# Value where category axis crosses.",
"grbit",
"=",
"0x011F",
"# Format flags.",
"# TODO. Reverse doubles when they are handled.",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"'vv'",
")",
"data",
"=",
"[",
"numMin",
"]",
".",
"pack",
"(",
"'d'",
")",
"data",
"+=",
"[",
"numMax",
"]",
".",
"pack",
"(",
"'d'",
")",
"data",
"+=",
"[",
"numMajor",
"]",
".",
"pack",
"(",
"'d'",
")",
"data",
"+=",
"[",
"numMinor",
"]",
".",
"pack",
"(",
"'d'",
")",
"data",
"+=",
"[",
"numCross",
"]",
".",
"pack",
"(",
"'d'",
")",
"data",
"+=",
"[",
"grbit",
"]",
".",
"pack",
"(",
"'v'",
")",
"append",
"(",
"header",
",",
"data",
")",
"end"
] |
Write the VALUERANGE chart BIFF record.
|
[
"Write",
"the",
"VALUERANGE",
"chart",
"BIFF",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/chart.rb#L1864-L1885
|
19,065
|
cxn03651/writeexcel
|
lib/writeexcel/formula.rb
|
Writeexcel.Formula.parse_formula
|
def parse_formula(formula, byte_stream = false)
# Build the parse tree for the formula
tokens = reverse(parse(formula))
# Add a volatile token if the formula contains a volatile function.
# This must be the first token in the list
#
tokens.unshift('_vol') if check_volatile(tokens) != 0
# The return value depends on which Worksheet.pm method is the caller
unless byte_stream
# Parse formula to see if it throws any errors and then
# return raw tokens to Worksheet::store_formula()
#
parse_tokens(tokens)
tokens
else
# Return byte stream to Worksheet::write_formula()
parse_tokens(tokens)
end
end
|
ruby
|
def parse_formula(formula, byte_stream = false)
# Build the parse tree for the formula
tokens = reverse(parse(formula))
# Add a volatile token if the formula contains a volatile function.
# This must be the first token in the list
#
tokens.unshift('_vol') if check_volatile(tokens) != 0
# The return value depends on which Worksheet.pm method is the caller
unless byte_stream
# Parse formula to see if it throws any errors and then
# return raw tokens to Worksheet::store_formula()
#
parse_tokens(tokens)
tokens
else
# Return byte stream to Worksheet::write_formula()
parse_tokens(tokens)
end
end
|
[
"def",
"parse_formula",
"(",
"formula",
",",
"byte_stream",
"=",
"false",
")",
"# Build the parse tree for the formula",
"tokens",
"=",
"reverse",
"(",
"parse",
"(",
"formula",
")",
")",
"# Add a volatile token if the formula contains a volatile function.",
"# This must be the first token in the list",
"#",
"tokens",
".",
"unshift",
"(",
"'_vol'",
")",
"if",
"check_volatile",
"(",
"tokens",
")",
"!=",
"0",
"# The return value depends on which Worksheet.pm method is the caller",
"unless",
"byte_stream",
"# Parse formula to see if it throws any errors and then",
"# return raw tokens to Worksheet::store_formula()",
"#",
"parse_tokens",
"(",
"tokens",
")",
"tokens",
"else",
"# Return byte stream to Worksheet::write_formula()",
"parse_tokens",
"(",
"tokens",
")",
"end",
"end"
] |
Takes a textual description of a formula and returns a RPN encoded byte
string.
|
[
"Takes",
"a",
"textual",
"description",
"of",
"a",
"formula",
"and",
"returns",
"a",
"RPN",
"encoded",
"byte",
"string",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/formula.rb#L38-L58
|
19,066
|
cxn03651/writeexcel
|
lib/writeexcel/formula.rb
|
Writeexcel.Formula.parse_tokens
|
def parse_tokens(tokens)
parse_str = ''
last_type = ''
modifier = ''
num_args = 0
_class = 0
_classary = [1]
args = tokens.dup
# A note about the class modifiers used below. In general the class,
# "reference" or "value", of a function is applied to all of its operands.
# However, in certain circumstances the operands can have mixed classes,
# e.g. =VLOOKUP with external references. These will eventually be dealt
# with by the parser. However, as a workaround the class type of a token
# can be changed via the repeat_formula interface. Thus, a _ref2d token can
# be changed by the user to _ref2dA or _ref2dR to change its token class.
#
while (!args.empty?)
token = args.shift
if (token == '_arg')
num_args = args.shift
elsif (token == '_class')
token = args.shift
_class = @functions[token][2]
# If _class is undef then it means that the function isn't valid.
exit "Unknown function #{token}() in formula\n" if _class.nil?
_classary.push(_class)
elsif (token == '_vol')
parse_str += convert_volatile()
elsif (token == 'ptgBool')
token = args.shift
parse_str += convert_bool(token)
elsif (token == '_num')
token = args.shift
parse_str += convert_number(token)
elsif (token == '_str')
token = args.shift
parse_str += convert_string(token)
elsif (token =~ /^_ref2d/)
modifier = token.sub(/_ref2d/, '')
_class = _classary[-1]
_class = 0 if modifier == 'R'
_class = 1 if modifier == 'V'
token = args.shift
parse_str += convert_ref2d(token, _class)
elsif (token =~ /^_ref3d/)
modifier = token.sub(/_ref3d/,'')
_class = _classary[-1]
_class = 0 if modifier == 'R'
_class = 1 if modifier == 'V'
token = args.shift
parse_str += convert_ref3d(token, _class)
elsif (token =~ /^_range2d/)
modifier = token.sub(/_range2d/,'')
_class = _classary[-1]
_class = 0 if modifier == 'R'
_class = 1 if modifier == 'V'
token = args.shift
parse_str += convert_range2d(token, _class)
elsif (token =~ /^_range3d/)
modifier = token.sub(/_range3d/,'')
_class = _classary[-1]
_class = 0 if modifier == 'R'
_class = 1 if modifier == 'V'
token = args.shift
parse_str += convert_range3d(token, _class)
elsif (token =~ /^_name/)
modifier = token.sub(/_name/, '')
_class = _classary[-1]
_class = 0 if modifier == 'R'
_class = 1 if modifier == 'V'
token = args.shift
parse_str += convert_name(token, _class)
elsif (token == '_func')
token = args.shift
parse_str += convert_function(token, num_args.to_i)
_classary.pop
num_args = 0 # Reset after use
elsif @ptg[token]
parse_str += [@ptg[token]].pack("C")
else
# Unrecognised token
return nil
end
end
parse_str
end
|
ruby
|
def parse_tokens(tokens)
parse_str = ''
last_type = ''
modifier = ''
num_args = 0
_class = 0
_classary = [1]
args = tokens.dup
# A note about the class modifiers used below. In general the class,
# "reference" or "value", of a function is applied to all of its operands.
# However, in certain circumstances the operands can have mixed classes,
# e.g. =VLOOKUP with external references. These will eventually be dealt
# with by the parser. However, as a workaround the class type of a token
# can be changed via the repeat_formula interface. Thus, a _ref2d token can
# be changed by the user to _ref2dA or _ref2dR to change its token class.
#
while (!args.empty?)
token = args.shift
if (token == '_arg')
num_args = args.shift
elsif (token == '_class')
token = args.shift
_class = @functions[token][2]
# If _class is undef then it means that the function isn't valid.
exit "Unknown function #{token}() in formula\n" if _class.nil?
_classary.push(_class)
elsif (token == '_vol')
parse_str += convert_volatile()
elsif (token == 'ptgBool')
token = args.shift
parse_str += convert_bool(token)
elsif (token == '_num')
token = args.shift
parse_str += convert_number(token)
elsif (token == '_str')
token = args.shift
parse_str += convert_string(token)
elsif (token =~ /^_ref2d/)
modifier = token.sub(/_ref2d/, '')
_class = _classary[-1]
_class = 0 if modifier == 'R'
_class = 1 if modifier == 'V'
token = args.shift
parse_str += convert_ref2d(token, _class)
elsif (token =~ /^_ref3d/)
modifier = token.sub(/_ref3d/,'')
_class = _classary[-1]
_class = 0 if modifier == 'R'
_class = 1 if modifier == 'V'
token = args.shift
parse_str += convert_ref3d(token, _class)
elsif (token =~ /^_range2d/)
modifier = token.sub(/_range2d/,'')
_class = _classary[-1]
_class = 0 if modifier == 'R'
_class = 1 if modifier == 'V'
token = args.shift
parse_str += convert_range2d(token, _class)
elsif (token =~ /^_range3d/)
modifier = token.sub(/_range3d/,'')
_class = _classary[-1]
_class = 0 if modifier == 'R'
_class = 1 if modifier == 'V'
token = args.shift
parse_str += convert_range3d(token, _class)
elsif (token =~ /^_name/)
modifier = token.sub(/_name/, '')
_class = _classary[-1]
_class = 0 if modifier == 'R'
_class = 1 if modifier == 'V'
token = args.shift
parse_str += convert_name(token, _class)
elsif (token == '_func')
token = args.shift
parse_str += convert_function(token, num_args.to_i)
_classary.pop
num_args = 0 # Reset after use
elsif @ptg[token]
parse_str += [@ptg[token]].pack("C")
else
# Unrecognised token
return nil
end
end
parse_str
end
|
[
"def",
"parse_tokens",
"(",
"tokens",
")",
"parse_str",
"=",
"''",
"last_type",
"=",
"''",
"modifier",
"=",
"''",
"num_args",
"=",
"0",
"_class",
"=",
"0",
"_classary",
"=",
"[",
"1",
"]",
"args",
"=",
"tokens",
".",
"dup",
"# A note about the class modifiers used below. In general the class,",
"# \"reference\" or \"value\", of a function is applied to all of its operands.",
"# However, in certain circumstances the operands can have mixed classes,",
"# e.g. =VLOOKUP with external references. These will eventually be dealt",
"# with by the parser. However, as a workaround the class type of a token",
"# can be changed via the repeat_formula interface. Thus, a _ref2d token can",
"# be changed by the user to _ref2dA or _ref2dR to change its token class.",
"#",
"while",
"(",
"!",
"args",
".",
"empty?",
")",
"token",
"=",
"args",
".",
"shift",
"if",
"(",
"token",
"==",
"'_arg'",
")",
"num_args",
"=",
"args",
".",
"shift",
"elsif",
"(",
"token",
"==",
"'_class'",
")",
"token",
"=",
"args",
".",
"shift",
"_class",
"=",
"@functions",
"[",
"token",
"]",
"[",
"2",
"]",
"# If _class is undef then it means that the function isn't valid.",
"exit",
"\"Unknown function #{token}() in formula\\n\"",
"if",
"_class",
".",
"nil?",
"_classary",
".",
"push",
"(",
"_class",
")",
"elsif",
"(",
"token",
"==",
"'_vol'",
")",
"parse_str",
"+=",
"convert_volatile",
"(",
")",
"elsif",
"(",
"token",
"==",
"'ptgBool'",
")",
"token",
"=",
"args",
".",
"shift",
"parse_str",
"+=",
"convert_bool",
"(",
"token",
")",
"elsif",
"(",
"token",
"==",
"'_num'",
")",
"token",
"=",
"args",
".",
"shift",
"parse_str",
"+=",
"convert_number",
"(",
"token",
")",
"elsif",
"(",
"token",
"==",
"'_str'",
")",
"token",
"=",
"args",
".",
"shift",
"parse_str",
"+=",
"convert_string",
"(",
"token",
")",
"elsif",
"(",
"token",
"=~",
"/",
"/",
")",
"modifier",
"=",
"token",
".",
"sub",
"(",
"/",
"/",
",",
"''",
")",
"_class",
"=",
"_classary",
"[",
"-",
"1",
"]",
"_class",
"=",
"0",
"if",
"modifier",
"==",
"'R'",
"_class",
"=",
"1",
"if",
"modifier",
"==",
"'V'",
"token",
"=",
"args",
".",
"shift",
"parse_str",
"+=",
"convert_ref2d",
"(",
"token",
",",
"_class",
")",
"elsif",
"(",
"token",
"=~",
"/",
"/",
")",
"modifier",
"=",
"token",
".",
"sub",
"(",
"/",
"/",
",",
"''",
")",
"_class",
"=",
"_classary",
"[",
"-",
"1",
"]",
"_class",
"=",
"0",
"if",
"modifier",
"==",
"'R'",
"_class",
"=",
"1",
"if",
"modifier",
"==",
"'V'",
"token",
"=",
"args",
".",
"shift",
"parse_str",
"+=",
"convert_ref3d",
"(",
"token",
",",
"_class",
")",
"elsif",
"(",
"token",
"=~",
"/",
"/",
")",
"modifier",
"=",
"token",
".",
"sub",
"(",
"/",
"/",
",",
"''",
")",
"_class",
"=",
"_classary",
"[",
"-",
"1",
"]",
"_class",
"=",
"0",
"if",
"modifier",
"==",
"'R'",
"_class",
"=",
"1",
"if",
"modifier",
"==",
"'V'",
"token",
"=",
"args",
".",
"shift",
"parse_str",
"+=",
"convert_range2d",
"(",
"token",
",",
"_class",
")",
"elsif",
"(",
"token",
"=~",
"/",
"/",
")",
"modifier",
"=",
"token",
".",
"sub",
"(",
"/",
"/",
",",
"''",
")",
"_class",
"=",
"_classary",
"[",
"-",
"1",
"]",
"_class",
"=",
"0",
"if",
"modifier",
"==",
"'R'",
"_class",
"=",
"1",
"if",
"modifier",
"==",
"'V'",
"token",
"=",
"args",
".",
"shift",
"parse_str",
"+=",
"convert_range3d",
"(",
"token",
",",
"_class",
")",
"elsif",
"(",
"token",
"=~",
"/",
"/",
")",
"modifier",
"=",
"token",
".",
"sub",
"(",
"/",
"/",
",",
"''",
")",
"_class",
"=",
"_classary",
"[",
"-",
"1",
"]",
"_class",
"=",
"0",
"if",
"modifier",
"==",
"'R'",
"_class",
"=",
"1",
"if",
"modifier",
"==",
"'V'",
"token",
"=",
"args",
".",
"shift",
"parse_str",
"+=",
"convert_name",
"(",
"token",
",",
"_class",
")",
"elsif",
"(",
"token",
"==",
"'_func'",
")",
"token",
"=",
"args",
".",
"shift",
"parse_str",
"+=",
"convert_function",
"(",
"token",
",",
"num_args",
".",
"to_i",
")",
"_classary",
".",
"pop",
"num_args",
"=",
"0",
"# Reset after use",
"elsif",
"@ptg",
"[",
"token",
"]",
"parse_str",
"+=",
"[",
"@ptg",
"[",
"token",
"]",
"]",
".",
"pack",
"(",
"\"C\"",
")",
"else",
"# Unrecognised token",
"return",
"nil",
"end",
"end",
"parse_str",
"end"
] |
Convert each token or token pair to its Excel 'ptg' equivalent.
|
[
"Convert",
"each",
"token",
"or",
"token",
"pair",
"to",
"its",
"Excel",
"ptg",
"equivalent",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/formula.rb#L63-L150
|
19,067
|
cxn03651/writeexcel
|
lib/writeexcel/formula.rb
|
Writeexcel.Formula.convert_number
|
def convert_number(num)
# Integer in the range 0..2**16-1
if ((num =~ /^\d+$/) && (num.to_i <= 65535))
return [@ptg['ptgInt'], num.to_i].pack("Cv")
else # A float
num = [num.to_f].pack("d")
num.reverse! if @byte_order
return [@ptg['ptgNum']].pack("C") + num
end
end
|
ruby
|
def convert_number(num)
# Integer in the range 0..2**16-1
if ((num =~ /^\d+$/) && (num.to_i <= 65535))
return [@ptg['ptgInt'], num.to_i].pack("Cv")
else # A float
num = [num.to_f].pack("d")
num.reverse! if @byte_order
return [@ptg['ptgNum']].pack("C") + num
end
end
|
[
"def",
"convert_number",
"(",
"num",
")",
"# Integer in the range 0..2**16-1",
"if",
"(",
"(",
"num",
"=~",
"/",
"\\d",
"/",
")",
"&&",
"(",
"num",
".",
"to_i",
"<=",
"65535",
")",
")",
"return",
"[",
"@ptg",
"[",
"'ptgInt'",
"]",
",",
"num",
".",
"to_i",
"]",
".",
"pack",
"(",
"\"Cv\"",
")",
"else",
"# A float",
"num",
"=",
"[",
"num",
".",
"to_f",
"]",
".",
"pack",
"(",
"\"d\"",
")",
"num",
".",
"reverse!",
"if",
"@byte_order",
"return",
"[",
"@ptg",
"[",
"'ptgNum'",
"]",
"]",
".",
"pack",
"(",
"\"C\"",
")",
"+",
"num",
"end",
"end"
] |
Convert a number token to ptgInt or ptgNum
|
[
"Convert",
"a",
"number",
"token",
"to",
"ptgInt",
"or",
"ptgNum"
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/formula.rb#L265-L274
|
19,068
|
cxn03651/writeexcel
|
lib/writeexcel/formula.rb
|
Writeexcel.Formula.convert_string
|
def convert_string(str)
ruby_19 { str = convert_to_ascii_if_ascii(str) }
encoding = 0
str.sub!(/^"/,'') # Remove leading "
str.sub!(/"$/,'') # Remove trailing "
str.gsub!(/""/,'"') # Substitute Excel's escaped double quote "" for "
# number of characters in str
length = ruby_18 { str.gsub(/[^\WA-Za-z_\d]/, ' ').length } ||
ruby_19 { str.length }
# Handle utf8 strings
if is_utf8?(str)
str = utf8_to_16le(str)
ruby_19 { str.force_encoding('BINARY') }
encoding = 1
end
exit "String in formula has more than 255 chars\n" if length > 255
[@ptg['ptgStr'], length, encoding].pack("CCC") + str
end
|
ruby
|
def convert_string(str)
ruby_19 { str = convert_to_ascii_if_ascii(str) }
encoding = 0
str.sub!(/^"/,'') # Remove leading "
str.sub!(/"$/,'') # Remove trailing "
str.gsub!(/""/,'"') # Substitute Excel's escaped double quote "" for "
# number of characters in str
length = ruby_18 { str.gsub(/[^\WA-Za-z_\d]/, ' ').length } ||
ruby_19 { str.length }
# Handle utf8 strings
if is_utf8?(str)
str = utf8_to_16le(str)
ruby_19 { str.force_encoding('BINARY') }
encoding = 1
end
exit "String in formula has more than 255 chars\n" if length > 255
[@ptg['ptgStr'], length, encoding].pack("CCC") + str
end
|
[
"def",
"convert_string",
"(",
"str",
")",
"ruby_19",
"{",
"str",
"=",
"convert_to_ascii_if_ascii",
"(",
"str",
")",
"}",
"encoding",
"=",
"0",
"str",
".",
"sub!",
"(",
"/",
"/",
",",
"''",
")",
"# Remove leading \"",
"str",
".",
"sub!",
"(",
"/",
"/",
",",
"''",
")",
"# Remove trailing \"",
"str",
".",
"gsub!",
"(",
"/",
"/",
",",
"'\"'",
")",
"# Substitute Excel's escaped double quote \"\" for \"",
"# number of characters in str",
"length",
"=",
"ruby_18",
"{",
"str",
".",
"gsub",
"(",
"/",
"\\W",
"\\d",
"/",
",",
"' '",
")",
".",
"length",
"}",
"||",
"ruby_19",
"{",
"str",
".",
"length",
"}",
"# Handle utf8 strings",
"if",
"is_utf8?",
"(",
"str",
")",
"str",
"=",
"utf8_to_16le",
"(",
"str",
")",
"ruby_19",
"{",
"str",
".",
"force_encoding",
"(",
"'BINARY'",
")",
"}",
"encoding",
"=",
"1",
"end",
"exit",
"\"String in formula has more than 255 chars\\n\"",
"if",
"length",
">",
"255",
"[",
"@ptg",
"[",
"'ptgStr'",
"]",
",",
"length",
",",
"encoding",
"]",
".",
"pack",
"(",
"\"CCC\"",
")",
"+",
"str",
"end"
] |
Convert a string to a ptg Str.
|
[
"Convert",
"a",
"string",
"to",
"a",
"ptg",
"Str",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/formula.rb#L279-L302
|
19,069
|
cxn03651/writeexcel
|
lib/writeexcel/formula.rb
|
Writeexcel.Formula.convert_function
|
def convert_function(token, num_args)
exit "Unknown function #{token}() in formula\n" if @functions[token][0].nil?
args = @functions[token][1]
# Fixed number of args eg. TIME($i,$j,$k).
if (args >= 0)
# Check that the number of args is valid.
if (args != num_args)
raise "Incorrect number of arguments for #{token}() in formula\n"
else
return [@ptg['ptgFuncV'], @functions[token][0]].pack("Cv")
end
end
# Variable number of args eg. SUM(i,j,k, ..).
if (args == -1)
return [@ptg['ptgFuncVarV'], num_args, @functions[token][0]].pack("CCv")
end
end
|
ruby
|
def convert_function(token, num_args)
exit "Unknown function #{token}() in formula\n" if @functions[token][0].nil?
args = @functions[token][1]
# Fixed number of args eg. TIME($i,$j,$k).
if (args >= 0)
# Check that the number of args is valid.
if (args != num_args)
raise "Incorrect number of arguments for #{token}() in formula\n"
else
return [@ptg['ptgFuncV'], @functions[token][0]].pack("Cv")
end
end
# Variable number of args eg. SUM(i,j,k, ..).
if (args == -1)
return [@ptg['ptgFuncVarV'], num_args, @functions[token][0]].pack("CCv")
end
end
|
[
"def",
"convert_function",
"(",
"token",
",",
"num_args",
")",
"exit",
"\"Unknown function #{token}() in formula\\n\"",
"if",
"@functions",
"[",
"token",
"]",
"[",
"0",
"]",
".",
"nil?",
"args",
"=",
"@functions",
"[",
"token",
"]",
"[",
"1",
"]",
"# Fixed number of args eg. TIME($i,$j,$k).",
"if",
"(",
"args",
">=",
"0",
")",
"# Check that the number of args is valid.",
"if",
"(",
"args",
"!=",
"num_args",
")",
"raise",
"\"Incorrect number of arguments for #{token}() in formula\\n\"",
"else",
"return",
"[",
"@ptg",
"[",
"'ptgFuncV'",
"]",
",",
"@functions",
"[",
"token",
"]",
"[",
"0",
"]",
"]",
".",
"pack",
"(",
"\"Cv\"",
")",
"end",
"end",
"# Variable number of args eg. SUM(i,j,k, ..).",
"if",
"(",
"args",
"==",
"-",
"1",
")",
"return",
"[",
"@ptg",
"[",
"'ptgFuncVarV'",
"]",
",",
"num_args",
",",
"@functions",
"[",
"token",
"]",
"[",
"0",
"]",
"]",
".",
"pack",
"(",
"\"CCv\"",
")",
"end",
"end"
] |
Convert a function to a ptgFunc or ptgFuncVarV depending on the number of
args that it takes.
|
[
"Convert",
"a",
"function",
"to",
"a",
"ptgFunc",
"or",
"ptgFuncVarV",
"depending",
"on",
"the",
"number",
"of",
"args",
"that",
"it",
"takes",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/formula.rb#L532-L551
|
19,070
|
cxn03651/writeexcel
|
lib/writeexcel/formula.rb
|
Writeexcel.Formula.convert_name
|
def convert_name(name, _class)
name_index = get_name_index(name)
# The ptg value depends on the class of the ptg.
if _class == 0
ptgName = @ptg['ptgName']
elsif _class == 1
ptgName = @ptg['ptgNameV']
elsif _class == 2
ptgName = @ptg['ptgNameA']
end
[ptgName, name_index].pack('CV')
end
|
ruby
|
def convert_name(name, _class)
name_index = get_name_index(name)
# The ptg value depends on the class of the ptg.
if _class == 0
ptgName = @ptg['ptgName']
elsif _class == 1
ptgName = @ptg['ptgNameV']
elsif _class == 2
ptgName = @ptg['ptgNameA']
end
[ptgName, name_index].pack('CV')
end
|
[
"def",
"convert_name",
"(",
"name",
",",
"_class",
")",
"name_index",
"=",
"get_name_index",
"(",
"name",
")",
"# The ptg value depends on the class of the ptg.",
"if",
"_class",
"==",
"0",
"ptgName",
"=",
"@ptg",
"[",
"'ptgName'",
"]",
"elsif",
"_class",
"==",
"1",
"ptgName",
"=",
"@ptg",
"[",
"'ptgNameV'",
"]",
"elsif",
"_class",
"==",
"2",
"ptgName",
"=",
"@ptg",
"[",
"'ptgNameA'",
"]",
"end",
"[",
"ptgName",
",",
"name_index",
"]",
".",
"pack",
"(",
"'CV'",
")",
"end"
] |
Convert a symbolic name into a name reference.
|
[
"Convert",
"a",
"symbolic",
"name",
"into",
"a",
"name",
"reference",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/formula.rb#L556-L569
|
19,071
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.close
|
def close #:nodoc:
################################################
# Prepend in reverse order!!
#
# Prepend the sheet dimensions
store_dimensions
# Prepend the autofilter filters.
store_autofilters
# Prepend the sheet autofilter info.
store_autofilterinfo
# Prepend the sheet filtermode record.
store_filtermode
# Prepend the COLINFO records if they exist
@colinfo.reverse.each do |colinfo|
store_colinfo(colinfo)
end
# Prepend the DEFCOLWIDTH record
store_defcol
# Prepend the sheet password
store_password
# Prepend the sheet protection
store_protect
store_obj_protect
# Prepend the page setup
store_setup
# Prepend the bottom margin
store_margin_bottom
# Prepend the top margin
store_margin_top
# Prepend the right margin
store_margin_right
# Prepend the left margin
store_margin_left
# Prepend the page vertical centering
store_vcenter
# Prepend the page horizontal centering
store_hcenter
# Prepend the page footer
store_footer
# Prepend the page header
store_header
# Prepend the vertical page breaks
store_vbreak
# Prepend the horizontal page breaks
store_hbreak
# Prepend WSBOOL
store_wsbool
# Prepend the default row height.
store_defrow
# Prepend GUTS
store_guts
# Prepend GRIDSET
store_gridset
# Prepend PRINTGRIDLINES
store_print_gridlines
# Prepend PRINTHEADERS
store_print_headers
#
# End of prepend. Read upwards from here.
################################################
# Append
store_table
store_images
store_charts
store_filters
store_comments
store_window2
store_page_view
store_zoom
store_panes(*@panes) if @panes && !@panes.empty?
store_selection(*@selection)
store_validation_count
store_validations
store_tab_color
store_eof
# Prepend the BOF and INDEX records
store_index
store_bof(0x0010)
end
|
ruby
|
def close #:nodoc:
################################################
# Prepend in reverse order!!
#
# Prepend the sheet dimensions
store_dimensions
# Prepend the autofilter filters.
store_autofilters
# Prepend the sheet autofilter info.
store_autofilterinfo
# Prepend the sheet filtermode record.
store_filtermode
# Prepend the COLINFO records if they exist
@colinfo.reverse.each do |colinfo|
store_colinfo(colinfo)
end
# Prepend the DEFCOLWIDTH record
store_defcol
# Prepend the sheet password
store_password
# Prepend the sheet protection
store_protect
store_obj_protect
# Prepend the page setup
store_setup
# Prepend the bottom margin
store_margin_bottom
# Prepend the top margin
store_margin_top
# Prepend the right margin
store_margin_right
# Prepend the left margin
store_margin_left
# Prepend the page vertical centering
store_vcenter
# Prepend the page horizontal centering
store_hcenter
# Prepend the page footer
store_footer
# Prepend the page header
store_header
# Prepend the vertical page breaks
store_vbreak
# Prepend the horizontal page breaks
store_hbreak
# Prepend WSBOOL
store_wsbool
# Prepend the default row height.
store_defrow
# Prepend GUTS
store_guts
# Prepend GRIDSET
store_gridset
# Prepend PRINTGRIDLINES
store_print_gridlines
# Prepend PRINTHEADERS
store_print_headers
#
# End of prepend. Read upwards from here.
################################################
# Append
store_table
store_images
store_charts
store_filters
store_comments
store_window2
store_page_view
store_zoom
store_panes(*@panes) if @panes && !@panes.empty?
store_selection(*@selection)
store_validation_count
store_validations
store_tab_color
store_eof
# Prepend the BOF and INDEX records
store_index
store_bof(0x0010)
end
|
[
"def",
"close",
"#:nodoc:",
"################################################",
"# Prepend in reverse order!!",
"#",
"# Prepend the sheet dimensions",
"store_dimensions",
"# Prepend the autofilter filters.",
"store_autofilters",
"# Prepend the sheet autofilter info.",
"store_autofilterinfo",
"# Prepend the sheet filtermode record.",
"store_filtermode",
"# Prepend the COLINFO records if they exist",
"@colinfo",
".",
"reverse",
".",
"each",
"do",
"|",
"colinfo",
"|",
"store_colinfo",
"(",
"colinfo",
")",
"end",
"# Prepend the DEFCOLWIDTH record",
"store_defcol",
"# Prepend the sheet password",
"store_password",
"# Prepend the sheet protection",
"store_protect",
"store_obj_protect",
"# Prepend the page setup",
"store_setup",
"# Prepend the bottom margin",
"store_margin_bottom",
"# Prepend the top margin",
"store_margin_top",
"# Prepend the right margin",
"store_margin_right",
"# Prepend the left margin",
"store_margin_left",
"# Prepend the page vertical centering",
"store_vcenter",
"# Prepend the page horizontal centering",
"store_hcenter",
"# Prepend the page footer",
"store_footer",
"# Prepend the page header",
"store_header",
"# Prepend the vertical page breaks",
"store_vbreak",
"# Prepend the horizontal page breaks",
"store_hbreak",
"# Prepend WSBOOL",
"store_wsbool",
"# Prepend the default row height.",
"store_defrow",
"# Prepend GUTS",
"store_guts",
"# Prepend GRIDSET",
"store_gridset",
"# Prepend PRINTGRIDLINES",
"store_print_gridlines",
"# Prepend PRINTHEADERS",
"store_print_headers",
"#",
"# End of prepend. Read upwards from here.",
"################################################",
"# Append",
"store_table",
"store_images",
"store_charts",
"store_filters",
"store_comments",
"store_window2",
"store_page_view",
"store_zoom",
"store_panes",
"(",
"@panes",
")",
"if",
"@panes",
"&&",
"!",
"@panes",
".",
"empty?",
"store_selection",
"(",
"@selection",
")",
"store_validation_count",
"store_validations",
"store_tab_color",
"store_eof",
"# Prepend the BOF and INDEX records",
"store_index",
"store_bof",
"(",
"0x0010",
")",
"end"
] |
Constructor. Creates a new Worksheet object from a BIFFwriter object
Add data to the beginning of the workbook (note the reverse order)
and to the end of the workbook.
|
[
"Constructor",
".",
"Creates",
"a",
"new",
"Worksheet",
"object",
"from",
"a",
"BIFFwriter",
"object"
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L163-L268
|
19,072
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.hide
|
def hide
@hidden = true
# A hidden worksheet shouldn't be active or selected.
@selected = false
@workbook.worksheets.activesheet = @workbook.worksheets.first
@workbook.worksheets.firstsheet = @workbook.worksheets.first
end
|
ruby
|
def hide
@hidden = true
# A hidden worksheet shouldn't be active or selected.
@selected = false
@workbook.worksheets.activesheet = @workbook.worksheets.first
@workbook.worksheets.firstsheet = @workbook.worksheets.first
end
|
[
"def",
"hide",
"@hidden",
"=",
"true",
"# A hidden worksheet shouldn't be active or selected.",
"@selected",
"=",
"false",
"@workbook",
".",
"worksheets",
".",
"activesheet",
"=",
"@workbook",
".",
"worksheets",
".",
"first",
"@workbook",
".",
"worksheets",
".",
"firstsheet",
"=",
"@workbook",
".",
"worksheets",
".",
"first",
"end"
] |
Hide this worksheet.
The hide() method is used to hide a worksheet:
worksheet2.hide
You may wish to hide a worksheet in order to avoid confusing a user with
intermediate data or calculations.
A hidden worksheet can not be activated or selected so this method is
mutually exclusive with the activate() and select() methods. In addition,
since the first worksheet will default to being the active worksheet,
you cannot hide the first worksheet without activating another sheet:
worksheet2.activate
worksheet1.hide
|
[
"Hide",
"this",
"worksheet",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L355-L362
|
19,073
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.set_tab_color
|
def set_tab_color(color)
color = Colors.new.get_color(color)
color = 0 if color == 0x7FFF # Default color.
@tab_color = color
end
|
ruby
|
def set_tab_color(color)
color = Colors.new.get_color(color)
color = 0 if color == 0x7FFF # Default color.
@tab_color = color
end
|
[
"def",
"set_tab_color",
"(",
"color",
")",
"color",
"=",
"Colors",
".",
"new",
".",
"get_color",
"(",
"color",
")",
"color",
"=",
"0",
"if",
"color",
"==",
"0x7FFF",
"# Default color.",
"@tab_color",
"=",
"color",
"end"
] |
Set the colour of the worksheet colour.
The set_tab_color() method is used to change the colour of the worksheet
tab. This feature is only available in Excel 2002 and later. You can
use one of the standard colour names provided by the Format object or a
colour index. See "COLOURS IN EXCEL" and the set_custom_color() method.
worksheet1.set_tab_color('red')
worksheet2.set_tab_color(0x0C)
See the tab_colors.rb program in the examples directory of the distro.
|
[
"Set",
"the",
"colour",
"of",
"the",
"worksheet",
"colour",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L1065-L1069
|
19,074
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.position_object
|
def position_object(col_start, row_start, x1, y1, width, height) #:nodoc:
# col_start; # Col containing upper left corner of object
# x1; # Distance to left side of object
# row_start; # Row containing top left corner of object
# y1; # Distance to top of object
# col_end; # Col containing lower right corner of object
# x2; # Distance to right side of object
# row_end; # Row containing bottom right corner of object
# y2; # Distance to bottom of object
# width; # Width of image frame
# height; # Height of image frame
# Adjust start column for offsets that are greater than the col width
x1, col_start = adjust_col_position(x1, col_start)
# Adjust start row for offsets that are greater than the row height
y1, row_start = adjust_row_position(y1, row_start)
# Initialise end cell to the same as the start cell
col_end = col_start
row_end = row_start
width += x1
height += y1
# Subtract the underlying cell widths to find the end cell of the image
width, col_end = adjust_col_position(width, col_end)
# Subtract the underlying cell heights to find the end cell of the image
height, row_end = adjust_row_position(height, row_end)
# Bitmap isn't allowed to start or finish in a hidden cell, i.e. a cell
# with zero eight or width.
#
return if size_col(col_start) == 0
return if size_col(col_end) == 0
return if size_row(row_start) == 0
return if size_row(row_end) == 0
# Convert the pixel values to the percentage value expected by Excel
x1 = 1024.0 * x1 / size_col(col_start)
y1 = 256.0 * y1 / size_row(row_start)
x2 = 1024.0 * width / size_col(col_end)
y2 = 256.0 * height / size_row(row_end)
# Simulate ceil() without calling POSIX::ceil().
x1 = (x1 +0.5).to_i
y1 = (y1 +0.5).to_i
x2 = (x2 +0.5).to_i
y2 = (y2 +0.5).to_i
[
col_start, x1,
row_start, y1,
col_end, x2,
row_end, y2
]
end
|
ruby
|
def position_object(col_start, row_start, x1, y1, width, height) #:nodoc:
# col_start; # Col containing upper left corner of object
# x1; # Distance to left side of object
# row_start; # Row containing top left corner of object
# y1; # Distance to top of object
# col_end; # Col containing lower right corner of object
# x2; # Distance to right side of object
# row_end; # Row containing bottom right corner of object
# y2; # Distance to bottom of object
# width; # Width of image frame
# height; # Height of image frame
# Adjust start column for offsets that are greater than the col width
x1, col_start = adjust_col_position(x1, col_start)
# Adjust start row for offsets that are greater than the row height
y1, row_start = adjust_row_position(y1, row_start)
# Initialise end cell to the same as the start cell
col_end = col_start
row_end = row_start
width += x1
height += y1
# Subtract the underlying cell widths to find the end cell of the image
width, col_end = adjust_col_position(width, col_end)
# Subtract the underlying cell heights to find the end cell of the image
height, row_end = adjust_row_position(height, row_end)
# Bitmap isn't allowed to start or finish in a hidden cell, i.e. a cell
# with zero eight or width.
#
return if size_col(col_start) == 0
return if size_col(col_end) == 0
return if size_row(row_start) == 0
return if size_row(row_end) == 0
# Convert the pixel values to the percentage value expected by Excel
x1 = 1024.0 * x1 / size_col(col_start)
y1 = 256.0 * y1 / size_row(row_start)
x2 = 1024.0 * width / size_col(col_end)
y2 = 256.0 * height / size_row(row_end)
# Simulate ceil() without calling POSIX::ceil().
x1 = (x1 +0.5).to_i
y1 = (y1 +0.5).to_i
x2 = (x2 +0.5).to_i
y2 = (y2 +0.5).to_i
[
col_start, x1,
row_start, y1,
col_end, x2,
row_end, y2
]
end
|
[
"def",
"position_object",
"(",
"col_start",
",",
"row_start",
",",
"x1",
",",
"y1",
",",
"width",
",",
"height",
")",
"#:nodoc:",
"# col_start; # Col containing upper left corner of object",
"# x1; # Distance to left side of object",
"# row_start; # Row containing top left corner of object",
"# y1; # Distance to top of object",
"# col_end; # Col containing lower right corner of object",
"# x2; # Distance to right side of object",
"# row_end; # Row containing bottom right corner of object",
"# y2; # Distance to bottom of object",
"# width; # Width of image frame",
"# height; # Height of image frame",
"# Adjust start column for offsets that are greater than the col width",
"x1",
",",
"col_start",
"=",
"adjust_col_position",
"(",
"x1",
",",
"col_start",
")",
"# Adjust start row for offsets that are greater than the row height",
"y1",
",",
"row_start",
"=",
"adjust_row_position",
"(",
"y1",
",",
"row_start",
")",
"# Initialise end cell to the same as the start cell",
"col_end",
"=",
"col_start",
"row_end",
"=",
"row_start",
"width",
"+=",
"x1",
"height",
"+=",
"y1",
"# Subtract the underlying cell widths to find the end cell of the image",
"width",
",",
"col_end",
"=",
"adjust_col_position",
"(",
"width",
",",
"col_end",
")",
"# Subtract the underlying cell heights to find the end cell of the image",
"height",
",",
"row_end",
"=",
"adjust_row_position",
"(",
"height",
",",
"row_end",
")",
"# Bitmap isn't allowed to start or finish in a hidden cell, i.e. a cell",
"# with zero eight or width.",
"#",
"return",
"if",
"size_col",
"(",
"col_start",
")",
"==",
"0",
"return",
"if",
"size_col",
"(",
"col_end",
")",
"==",
"0",
"return",
"if",
"size_row",
"(",
"row_start",
")",
"==",
"0",
"return",
"if",
"size_row",
"(",
"row_end",
")",
"==",
"0",
"# Convert the pixel values to the percentage value expected by Excel",
"x1",
"=",
"1024.0",
"*",
"x1",
"/",
"size_col",
"(",
"col_start",
")",
"y1",
"=",
"256.0",
"*",
"y1",
"/",
"size_row",
"(",
"row_start",
")",
"x2",
"=",
"1024.0",
"*",
"width",
"/",
"size_col",
"(",
"col_end",
")",
"y2",
"=",
"256.0",
"*",
"height",
"/",
"size_row",
"(",
"row_end",
")",
"# Simulate ceil() without calling POSIX::ceil().",
"x1",
"=",
"(",
"x1",
"+",
"0.5",
")",
".",
"to_i",
"y1",
"=",
"(",
"y1",
"+",
"0.5",
")",
".",
"to_i",
"x2",
"=",
"(",
"x2",
"+",
"0.5",
")",
".",
"to_i",
"y2",
"=",
"(",
"y2",
"+",
"0.5",
")",
".",
"to_i",
"[",
"col_start",
",",
"x1",
",",
"row_start",
",",
"y1",
",",
"col_end",
",",
"x2",
",",
"row_end",
",",
"y2",
"]",
"end"
] |
Calculate the vertices that define the position of a graphical object within
the worksheet.
+------------+------------+
| A | B |
+-----+------------+------------+
| |(x1,y1) | |
| 1 |(A1)._______|______ |
| | | | |
| | | | |
+-----+----| BITMAP |-----+
| | | | |
| 2 | |______________. |
| | | (B2)|
| | | (x2,y2)|
+---- +------------+------------+
Example of a bitmap that covers some of the area from cell A1 to cell B2.
Based on the width and height of the bitmap we need to calculate 8 vars:
$col_start, $row_start, $col_end, $row_end, $x1, $y1, $x2, $y2.
The width and height of the cells are also variable and have to be taken into
account.
The values of $col_start and $row_start are passed in from the calling
function. The values of $col_end and $row_end are calculated by subtracting
the width and height of the bitmap from the width and height of the
underlying cells.
The vertices are expressed as a percentage of the underlying cell width as
follows (rhs values are in pixels):
x1 = X / W *1024
y1 = Y / H *256
x2 = (X-1) / W *1024
y2 = (Y-1) / H *256
Where: X is distance from the left side of the underlying cell
Y is distance from the top of the underlying cell
W is the width of the cell
H is the height of the cell
Note: the SDK incorrectly states that the height should be expressed as a
percentage of 1024.
|
[
"Calculate",
"the",
"vertices",
"that",
"define",
"the",
"position",
"of",
"a",
"graphical",
"object",
"within",
"the",
"worksheet",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L4410-L4471
|
19,075
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.store_mso_sp_container
|
def store_mso_sp_container(length) #:nodoc:
type = 0xF004
version = 15
instance = 0
data = ''
add_mso_generic(type, version, instance, data, length)
end
|
ruby
|
def store_mso_sp_container(length) #:nodoc:
type = 0xF004
version = 15
instance = 0
data = ''
add_mso_generic(type, version, instance, data, length)
end
|
[
"def",
"store_mso_sp_container",
"(",
"length",
")",
"#:nodoc:",
"type",
"=",
"0xF004",
"version",
"=",
"15",
"instance",
"=",
"0",
"data",
"=",
"''",
"add_mso_generic",
"(",
"type",
",",
"version",
",",
"instance",
",",
"data",
",",
"length",
")",
"end"
] |
Write the Escher SpContainer record that is part of MSODRAWING.
|
[
"Write",
"the",
"Escher",
"SpContainer",
"record",
"that",
"is",
"part",
"of",
"MSODRAWING",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L4489-L4496
|
19,076
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.store_mso_sp
|
def store_mso_sp(instance, spid, options) #:nodoc:
type = 0xF00A
version = 2
data = ''
length = 8
data = [spid, options].pack('VV')
add_mso_generic(type, version, instance, data, length)
end
|
ruby
|
def store_mso_sp(instance, spid, options) #:nodoc:
type = 0xF00A
version = 2
data = ''
length = 8
data = [spid, options].pack('VV')
add_mso_generic(type, version, instance, data, length)
end
|
[
"def",
"store_mso_sp",
"(",
"instance",
",",
"spid",
",",
"options",
")",
"#:nodoc:",
"type",
"=",
"0xF00A",
"version",
"=",
"2",
"data",
"=",
"''",
"length",
"=",
"8",
"data",
"=",
"[",
"spid",
",",
"options",
"]",
".",
"pack",
"(",
"'VV'",
")",
"add_mso_generic",
"(",
"type",
",",
"version",
",",
"instance",
",",
"data",
",",
"length",
")",
"end"
] |
Write the Escher Sp record that is part of MSODRAWING.
|
[
"Write",
"the",
"Escher",
"Sp",
"record",
"that",
"is",
"part",
"of",
"MSODRAWING",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L4501-L4509
|
19,077
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.store_mso_client_data
|
def store_mso_client_data #:nodoc:
type = 0xF011
version = 0
instance = 0
data = ''
length = 0
add_mso_generic(type, version, instance, data, length)
end
|
ruby
|
def store_mso_client_data #:nodoc:
type = 0xF011
version = 0
instance = 0
data = ''
length = 0
add_mso_generic(type, version, instance, data, length)
end
|
[
"def",
"store_mso_client_data",
"#:nodoc:",
"type",
"=",
"0xF011",
"version",
"=",
"0",
"instance",
"=",
"0",
"data",
"=",
"''",
"length",
"=",
"0",
"add_mso_generic",
"(",
"type",
",",
"version",
",",
"instance",
",",
"data",
",",
"length",
")",
"end"
] |
Write the Escher ClientData record that is part of MSODRAWING.
|
[
"Write",
"the",
"Escher",
"ClientData",
"record",
"that",
"is",
"part",
"of",
"MSODRAWING",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L4561-L4569
|
19,078
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.boundsheet
|
def boundsheet #:nodoc:
hidden = self.hidden? ? 1 : 0
encoding = self.is_name_utf16be? ? 1 : 0
record = 0x0085 # Record identifier
length = 0x08 + @name.bytesize # Number of bytes to follow
cch = @name.bytesize # Length of sheet name
# Character length is num of chars not num of bytes
cch /= 2 if is_name_utf16be?
# Change the UTF-16 name from BE to LE
sheetname = is_name_utf16be? ? @name.unpack('v*').pack('n*') : @name
grbit = @type | hidden
header = [record, length].pack("vv")
data = [@offset, grbit, cch, encoding].pack("VvCC")
header + data + sheetname
end
|
ruby
|
def boundsheet #:nodoc:
hidden = self.hidden? ? 1 : 0
encoding = self.is_name_utf16be? ? 1 : 0
record = 0x0085 # Record identifier
length = 0x08 + @name.bytesize # Number of bytes to follow
cch = @name.bytesize # Length of sheet name
# Character length is num of chars not num of bytes
cch /= 2 if is_name_utf16be?
# Change the UTF-16 name from BE to LE
sheetname = is_name_utf16be? ? @name.unpack('v*').pack('n*') : @name
grbit = @type | hidden
header = [record, length].pack("vv")
data = [@offset, grbit, cch, encoding].pack("VvCC")
header + data + sheetname
end
|
[
"def",
"boundsheet",
"#:nodoc:",
"hidden",
"=",
"self",
".",
"hidden?",
"?",
"1",
":",
"0",
"encoding",
"=",
"self",
".",
"is_name_utf16be?",
"?",
"1",
":",
"0",
"record",
"=",
"0x0085",
"# Record identifier",
"length",
"=",
"0x08",
"+",
"@name",
".",
"bytesize",
"# Number of bytes to follow",
"cch",
"=",
"@name",
".",
"bytesize",
"# Length of sheet name",
"# Character length is num of chars not num of bytes",
"cch",
"/=",
"2",
"if",
"is_name_utf16be?",
"# Change the UTF-16 name from BE to LE",
"sheetname",
"=",
"is_name_utf16be?",
"?",
"@name",
".",
"unpack",
"(",
"'v*'",
")",
".",
"pack",
"(",
"'n*'",
")",
":",
"@name",
"grbit",
"=",
"@type",
"|",
"hidden",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"\"vv\"",
")",
"data",
"=",
"[",
"@offset",
",",
"grbit",
",",
"cch",
",",
"encoding",
"]",
".",
"pack",
"(",
"\"VvCC\"",
")",
"header",
"+",
"data",
"+",
"sheetname",
"end"
] |
Excel BIFF BOUNDSHEET record.
sheetname # Worksheet name
offset # Location of worksheet BOF
type # Worksheet type
hidden # Worksheet hidden flag
encoding # Sheet name encoding
|
[
"Excel",
"BIFF",
"BOUNDSHEET",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L4584-L4605
|
19,079
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.parse_filter_expression
|
def parse_filter_expression(expression, tokens) #:nodoc:
# The number of tokens will be either 3 (for 1 expression)
# or 7 (for 2 expressions).
#
if (tokens.size == 7)
conditional = tokens[3]
if conditional =~ /^(and|&&)$/
conditional = 0
elsif conditional =~ /^(or|\|\|)$/
conditional = 1
else
raise "Token '#{conditional}' is not a valid conditional " +
"in filter expression '#{expression}'"
end
expression_1 = parse_filter_tokens(expression, tokens[0..2])
expression_2 = parse_filter_tokens(expression, tokens[4..6])
[expression_1, conditional, expression_2].flatten
else
parse_filter_tokens(expression, tokens)
end
end
|
ruby
|
def parse_filter_expression(expression, tokens) #:nodoc:
# The number of tokens will be either 3 (for 1 expression)
# or 7 (for 2 expressions).
#
if (tokens.size == 7)
conditional = tokens[3]
if conditional =~ /^(and|&&)$/
conditional = 0
elsif conditional =~ /^(or|\|\|)$/
conditional = 1
else
raise "Token '#{conditional}' is not a valid conditional " +
"in filter expression '#{expression}'"
end
expression_1 = parse_filter_tokens(expression, tokens[0..2])
expression_2 = parse_filter_tokens(expression, tokens[4..6])
[expression_1, conditional, expression_2].flatten
else
parse_filter_tokens(expression, tokens)
end
end
|
[
"def",
"parse_filter_expression",
"(",
"expression",
",",
"tokens",
")",
"#:nodoc:",
"# The number of tokens will be either 3 (for 1 expression)",
"# or 7 (for 2 expressions).",
"#",
"if",
"(",
"tokens",
".",
"size",
"==",
"7",
")",
"conditional",
"=",
"tokens",
"[",
"3",
"]",
"if",
"conditional",
"=~",
"/",
"/",
"conditional",
"=",
"0",
"elsif",
"conditional",
"=~",
"/",
"\\|",
"\\|",
"/",
"conditional",
"=",
"1",
"else",
"raise",
"\"Token '#{conditional}' is not a valid conditional \"",
"+",
"\"in filter expression '#{expression}'\"",
"end",
"expression_1",
"=",
"parse_filter_tokens",
"(",
"expression",
",",
"tokens",
"[",
"0",
"..",
"2",
"]",
")",
"expression_2",
"=",
"parse_filter_tokens",
"(",
"expression",
",",
"tokens",
"[",
"4",
"..",
"6",
"]",
")",
"[",
"expression_1",
",",
"conditional",
",",
"expression_2",
"]",
".",
"flatten",
"else",
"parse_filter_tokens",
"(",
"expression",
",",
"tokens",
")",
"end",
"end"
] |
Converts the tokens of a possibly conditional expression into 1 or 2
sub expressions for further parsing.
Examples:
('x', '==', 2000) -> exp1
('x', '>', 2000, 'and', 'x', '<', 5000) -> exp1 and exp2
|
[
"Converts",
"the",
"tokens",
"of",
"a",
"possibly",
"conditional",
"expression",
"into",
"1",
"or",
"2",
"sub",
"expressions",
"for",
"further",
"parsing",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L4775-L4795
|
19,080
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.xf_record_index
|
def xf_record_index(row, col, xf=nil) #:nodoc:
if xf.respond_to?(:xf_index)
xf.xf_index
elsif @row_formats.has_key?(row)
@row_formats[row].xf_index
elsif @col_formats.has_key?(col)
@col_formats[col].xf_index
else
0x0F
end
end
|
ruby
|
def xf_record_index(row, col, xf=nil) #:nodoc:
if xf.respond_to?(:xf_index)
xf.xf_index
elsif @row_formats.has_key?(row)
@row_formats[row].xf_index
elsif @col_formats.has_key?(col)
@col_formats[col].xf_index
else
0x0F
end
end
|
[
"def",
"xf_record_index",
"(",
"row",
",",
"col",
",",
"xf",
"=",
"nil",
")",
"#:nodoc:",
"if",
"xf",
".",
"respond_to?",
"(",
":xf_index",
")",
"xf",
".",
"xf_index",
"elsif",
"@row_formats",
".",
"has_key?",
"(",
"row",
")",
"@row_formats",
"[",
"row",
"]",
".",
"xf_index",
"elsif",
"@col_formats",
".",
"has_key?",
"(",
"col",
")",
"@col_formats",
"[",
"col",
"]",
".",
"xf_index",
"else",
"0x0F",
"end",
"end"
] |
Returns an index to the XF record in the workbook.
Note: this is a function, not a method.
|
[
"Returns",
"an",
"index",
"to",
"the",
"XF",
"record",
"in",
"the",
"workbook",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L4918-L4928
|
19,081
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.encode_password
|
def encode_password(password)
i = 0
chars = password.split(//)
count = chars.size
chars.collect! do |char|
i += 1
char = char.ord << i
low_15 = char & 0x7fff
high_15 = char & 0x7fff << 15
high_15 = high_15 >> 15
char = low_15 | high_15
end
encoded_password = 0x0000
chars.each { |c| encoded_password ^= c }
encoded_password ^= count
encoded_password ^= 0xCE4B
end
|
ruby
|
def encode_password(password)
i = 0
chars = password.split(//)
count = chars.size
chars.collect! do |char|
i += 1
char = char.ord << i
low_15 = char & 0x7fff
high_15 = char & 0x7fff << 15
high_15 = high_15 >> 15
char = low_15 | high_15
end
encoded_password = 0x0000
chars.each { |c| encoded_password ^= c }
encoded_password ^= count
encoded_password ^= 0xCE4B
end
|
[
"def",
"encode_password",
"(",
"password",
")",
"i",
"=",
"0",
"chars",
"=",
"password",
".",
"split",
"(",
"/",
"/",
")",
"count",
"=",
"chars",
".",
"size",
"chars",
".",
"collect!",
"do",
"|",
"char",
"|",
"i",
"+=",
"1",
"char",
"=",
"char",
".",
"ord",
"<<",
"i",
"low_15",
"=",
"char",
"&",
"0x7fff",
"high_15",
"=",
"char",
"&",
"0x7fff",
"<<",
"15",
"high_15",
"=",
"high_15",
">>",
"15",
"char",
"=",
"low_15",
"|",
"high_15",
"end",
"encoded_password",
"=",
"0x0000",
"chars",
".",
"each",
"{",
"|",
"c",
"|",
"encoded_password",
"^=",
"c",
"}",
"encoded_password",
"^=",
"count",
"encoded_password",
"^=",
"0xCE4B",
"end"
] |
Based on the algorithm provided by Daniel Rentz of OpenOffice.
|
[
"Based",
"on",
"the",
"algorithm",
"provided",
"by",
"Daniel",
"Rentz",
"of",
"OpenOffice",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L5005-L5023
|
19,082
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.get_formula_string
|
def get_formula_string(string) #:nodoc:
ruby_19 { string = convert_to_ascii_if_ascii(string) }
record = 0x0207 # Record identifier
length = 0x00 # Bytes to follow
# string # Formula string.
strlen = string.bytesize # Length of the formula string (chars).
encoding = 0 # String encoding.
# Handle utf8 strings.
if is_utf8?(string)
string = utf8_to_16be(string)
encoding = 1
end
length = 0x03 + string.bytesize # Length of the record data
header = [record, length].pack("vv")
data = [strlen, encoding].pack("vC")
header + data + string
end
|
ruby
|
def get_formula_string(string) #:nodoc:
ruby_19 { string = convert_to_ascii_if_ascii(string) }
record = 0x0207 # Record identifier
length = 0x00 # Bytes to follow
# string # Formula string.
strlen = string.bytesize # Length of the formula string (chars).
encoding = 0 # String encoding.
# Handle utf8 strings.
if is_utf8?(string)
string = utf8_to_16be(string)
encoding = 1
end
length = 0x03 + string.bytesize # Length of the record data
header = [record, length].pack("vv")
data = [strlen, encoding].pack("vC")
header + data + string
end
|
[
"def",
"get_formula_string",
"(",
"string",
")",
"#:nodoc:",
"ruby_19",
"{",
"string",
"=",
"convert_to_ascii_if_ascii",
"(",
"string",
")",
"}",
"record",
"=",
"0x0207",
"# Record identifier",
"length",
"=",
"0x00",
"# Bytes to follow",
"# string # Formula string.",
"strlen",
"=",
"string",
".",
"bytesize",
"# Length of the formula string (chars).",
"encoding",
"=",
"0",
"# String encoding.",
"# Handle utf8 strings.",
"if",
"is_utf8?",
"(",
"string",
")",
"string",
"=",
"utf8_to_16be",
"(",
"string",
")",
"encoding",
"=",
"1",
"end",
"length",
"=",
"0x03",
"+",
"string",
".",
"bytesize",
"# Length of the record data",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"\"vv\"",
")",
"data",
"=",
"[",
"strlen",
",",
"encoding",
"]",
".",
"pack",
"(",
"\"vC\"",
")",
"header",
"+",
"data",
"+",
"string",
"end"
] |
Pack the string value when a formula evaluates to a string. The value cannot
be calculated by the module and thus must be supplied by the user.
|
[
"Pack",
"the",
"string",
"value",
"when",
"a",
"formula",
"evaluates",
"to",
"a",
"string",
".",
"The",
"value",
"cannot",
"be",
"calculated",
"by",
"the",
"module",
"and",
"thus",
"must",
"be",
"supplied",
"by",
"the",
"user",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L5077-L5098
|
19,083
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.store_dimensions
|
def store_dimensions #:nodoc:
record = 0x0200 # Record identifier
length = 0x000E # Number of bytes to follow
reserved = 0x0000 # Reserved by Excel
@dimension.increment_row_max
@dimension.increment_col_max
header = [record, length].pack("vv")
fields = [@dimension.row_min, @dimension.row_max, @dimension.col_min, @dimension.col_max, reserved]
data = fields.pack("VVvvv")
prepend(header, data)
end
|
ruby
|
def store_dimensions #:nodoc:
record = 0x0200 # Record identifier
length = 0x000E # Number of bytes to follow
reserved = 0x0000 # Reserved by Excel
@dimension.increment_row_max
@dimension.increment_col_max
header = [record, length].pack("vv")
fields = [@dimension.row_min, @dimension.row_max, @dimension.col_min, @dimension.col_max, reserved]
data = fields.pack("VVvvv")
prepend(header, data)
end
|
[
"def",
"store_dimensions",
"#:nodoc:",
"record",
"=",
"0x0200",
"# Record identifier",
"length",
"=",
"0x000E",
"# Number of bytes to follow",
"reserved",
"=",
"0x0000",
"# Reserved by Excel",
"@dimension",
".",
"increment_row_max",
"@dimension",
".",
"increment_col_max",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"\"vv\"",
")",
"fields",
"=",
"[",
"@dimension",
".",
"row_min",
",",
"@dimension",
".",
"row_max",
",",
"@dimension",
".",
"col_min",
",",
"@dimension",
".",
"col_max",
",",
"reserved",
"]",
"data",
"=",
"fields",
".",
"pack",
"(",
"\"VVvvv\"",
")",
"prepend",
"(",
"header",
",",
"data",
")",
"end"
] |
Writes Excel DIMENSIONS to define the area in which there is cell data.
Notes:
Excel stores the max row/col as row/col +1.
Max and min values of 0 are used to indicate that no cell data.
We set the undef member data to 0 since it is used by store_table().
Inserting images or charts doesn't change the DIMENSION data.
|
[
"Writes",
"Excel",
"DIMENSIONS",
"to",
"define",
"the",
"area",
"in",
"which",
"there",
"is",
"cell",
"data",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L5508-L5521
|
19,084
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.store_window2
|
def store_window2 #:nodoc:
record = 0x023E # Record identifier
length = 0x0012 # Number of bytes to follow
grbit = 0x00B6 # Option flags
rwTop = @first_row # Top visible row
colLeft = @first_col # Leftmost visible column
rgbHdr = 0x00000040 # Row/col heading, grid color
wScaleSLV = 0x0000 # Zoom in page break preview
wScaleNormal = 0x0000 # Zoom in normal view
reserved = 0x00000000
# The options flags that comprise $grbit
fDspFmla = @display_formulas # 0 - bit
fDspGrid = @screen_gridlines # 1
fDspRwCol = @display_headers # 2
fFrozen = frozen? ? 1 : 0 # 3
fDspZeros = display_zeros? ? 1 : 0 # 4
fDefaultHdr = 1 # 5
fArabic = @display_arabic || 0 # 6
fDspGuts = @outline.visible? ? 1 : 0 # 7
fFrozenNoSplit = @frozen_no_split # 0 - bit
fSelected = selected? ? 1 : 0 # 1
fPaged = active? ? 1 : 0 # 2
fBreakPreview = 0 # 3
grbit = fDspFmla
grbit |= fDspGrid << 1
grbit |= fDspRwCol << 2
grbit |= fFrozen << 3
grbit |= fDspZeros << 4
grbit |= fDefaultHdr << 5
grbit |= fArabic << 6
grbit |= fDspGuts << 7
grbit |= fFrozenNoSplit << 8
grbit |= fSelected << 9
grbit |= fPaged << 10
grbit |= fBreakPreview << 11
header = [record, length].pack("vv")
data =[grbit, rwTop, colLeft, rgbHdr, wScaleSLV, wScaleNormal, reserved].pack("vvvVvvV")
append(header, data)
end
|
ruby
|
def store_window2 #:nodoc:
record = 0x023E # Record identifier
length = 0x0012 # Number of bytes to follow
grbit = 0x00B6 # Option flags
rwTop = @first_row # Top visible row
colLeft = @first_col # Leftmost visible column
rgbHdr = 0x00000040 # Row/col heading, grid color
wScaleSLV = 0x0000 # Zoom in page break preview
wScaleNormal = 0x0000 # Zoom in normal view
reserved = 0x00000000
# The options flags that comprise $grbit
fDspFmla = @display_formulas # 0 - bit
fDspGrid = @screen_gridlines # 1
fDspRwCol = @display_headers # 2
fFrozen = frozen? ? 1 : 0 # 3
fDspZeros = display_zeros? ? 1 : 0 # 4
fDefaultHdr = 1 # 5
fArabic = @display_arabic || 0 # 6
fDspGuts = @outline.visible? ? 1 : 0 # 7
fFrozenNoSplit = @frozen_no_split # 0 - bit
fSelected = selected? ? 1 : 0 # 1
fPaged = active? ? 1 : 0 # 2
fBreakPreview = 0 # 3
grbit = fDspFmla
grbit |= fDspGrid << 1
grbit |= fDspRwCol << 2
grbit |= fFrozen << 3
grbit |= fDspZeros << 4
grbit |= fDefaultHdr << 5
grbit |= fArabic << 6
grbit |= fDspGuts << 7
grbit |= fFrozenNoSplit << 8
grbit |= fSelected << 9
grbit |= fPaged << 10
grbit |= fBreakPreview << 11
header = [record, length].pack("vv")
data =[grbit, rwTop, colLeft, rgbHdr, wScaleSLV, wScaleNormal, reserved].pack("vvvVvvV")
append(header, data)
end
|
[
"def",
"store_window2",
"#:nodoc:",
"record",
"=",
"0x023E",
"# Record identifier",
"length",
"=",
"0x0012",
"# Number of bytes to follow",
"grbit",
"=",
"0x00B6",
"# Option flags",
"rwTop",
"=",
"@first_row",
"# Top visible row",
"colLeft",
"=",
"@first_col",
"# Leftmost visible column",
"rgbHdr",
"=",
"0x00000040",
"# Row/col heading, grid color",
"wScaleSLV",
"=",
"0x0000",
"# Zoom in page break preview",
"wScaleNormal",
"=",
"0x0000",
"# Zoom in normal view",
"reserved",
"=",
"0x00000000",
"# The options flags that comprise $grbit",
"fDspFmla",
"=",
"@display_formulas",
"# 0 - bit",
"fDspGrid",
"=",
"@screen_gridlines",
"# 1",
"fDspRwCol",
"=",
"@display_headers",
"# 2",
"fFrozen",
"=",
"frozen?",
"?",
"1",
":",
"0",
"# 3",
"fDspZeros",
"=",
"display_zeros?",
"?",
"1",
":",
"0",
"# 4",
"fDefaultHdr",
"=",
"1",
"# 5",
"fArabic",
"=",
"@display_arabic",
"||",
"0",
"# 6",
"fDspGuts",
"=",
"@outline",
".",
"visible?",
"?",
"1",
":",
"0",
"# 7",
"fFrozenNoSplit",
"=",
"@frozen_no_split",
"# 0 - bit",
"fSelected",
"=",
"selected?",
"?",
"1",
":",
"0",
"# 1",
"fPaged",
"=",
"active?",
"?",
"1",
":",
"0",
"# 2",
"fBreakPreview",
"=",
"0",
"# 3",
"grbit",
"=",
"fDspFmla",
"grbit",
"|=",
"fDspGrid",
"<<",
"1",
"grbit",
"|=",
"fDspRwCol",
"<<",
"2",
"grbit",
"|=",
"fFrozen",
"<<",
"3",
"grbit",
"|=",
"fDspZeros",
"<<",
"4",
"grbit",
"|=",
"fDefaultHdr",
"<<",
"5",
"grbit",
"|=",
"fArabic",
"<<",
"6",
"grbit",
"|=",
"fDspGuts",
"<<",
"7",
"grbit",
"|=",
"fFrozenNoSplit",
"<<",
"8",
"grbit",
"|=",
"fSelected",
"<<",
"9",
"grbit",
"|=",
"fPaged",
"<<",
"10",
"grbit",
"|=",
"fBreakPreview",
"<<",
"11",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"\"vv\"",
")",
"data",
"=",
"[",
"grbit",
",",
"rwTop",
",",
"colLeft",
",",
"rgbHdr",
",",
"wScaleSLV",
",",
"wScaleNormal",
",",
"reserved",
"]",
".",
"pack",
"(",
"\"vvvVvvV\"",
")",
"append",
"(",
"header",
",",
"data",
")",
"end"
] |
Write BIFF record Window2.
|
[
"Write",
"BIFF",
"record",
"Window2",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L5526-L5571
|
19,085
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.store_tab_color
|
def store_tab_color #:nodoc:
color = @tab_color
return if color == 0
record = 0x0862 # Record identifier
length = 0x0014 # Number of bytes to follow
zero = 0x0000
unknown = 0x0014
store_simple(record, length, record, zero, zero, zero, zero,
zero, unknown, zero, color, zero)
end
|
ruby
|
def store_tab_color #:nodoc:
color = @tab_color
return if color == 0
record = 0x0862 # Record identifier
length = 0x0014 # Number of bytes to follow
zero = 0x0000
unknown = 0x0014
store_simple(record, length, record, zero, zero, zero, zero,
zero, unknown, zero, color, zero)
end
|
[
"def",
"store_tab_color",
"#:nodoc:",
"color",
"=",
"@tab_color",
"return",
"if",
"color",
"==",
"0",
"record",
"=",
"0x0862",
"# Record identifier",
"length",
"=",
"0x0014",
"# Number of bytes to follow",
"zero",
"=",
"0x0000",
"unknown",
"=",
"0x0014",
"store_simple",
"(",
"record",
",",
"length",
",",
"record",
",",
"zero",
",",
"zero",
",",
"zero",
",",
"zero",
",",
"zero",
",",
"unknown",
",",
"zero",
",",
"color",
",",
"zero",
")",
"end"
] |
Write the Tab Color BIFF record.
|
[
"Write",
"the",
"Tab",
"Color",
"BIFF",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L5585-L5598
|
19,086
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.store_defrow
|
def store_defrow #:nodoc:
record = 0x0225 # Record identifier
length = 0x0004 # Number of bytes to follow
grbit = 0x0000 # Options.
height = 0x00FF # Default row height
header = [record, length].pack("vv")
data = [grbit, height].pack("vv")
prepend(header, data)
end
|
ruby
|
def store_defrow #:nodoc:
record = 0x0225 # Record identifier
length = 0x0004 # Number of bytes to follow
grbit = 0x0000 # Options.
height = 0x00FF # Default row height
header = [record, length].pack("vv")
data = [grbit, height].pack("vv")
prepend(header, data)
end
|
[
"def",
"store_defrow",
"#:nodoc:",
"record",
"=",
"0x0225",
"# Record identifier",
"length",
"=",
"0x0004",
"# Number of bytes to follow",
"grbit",
"=",
"0x0000",
"# Options.",
"height",
"=",
"0x00FF",
"# Default row height",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"\"vv\"",
")",
"data",
"=",
"[",
"grbit",
",",
"height",
"]",
".",
"pack",
"(",
"\"vv\"",
")",
"prepend",
"(",
"header",
",",
"data",
")",
"end"
] |
Write BIFF record DEFROWHEIGHT.
|
[
"Write",
"BIFF",
"record",
"DEFROWHEIGHT",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L5603-L5614
|
19,087
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.store_defcol
|
def store_defcol #:nodoc:
record = 0x0055 # Record identifier
length = 0x0002 # Number of bytes to follow
colwidth = 0x0008 # Default column width
header = [record, length].pack("vv")
data = [colwidth].pack("v")
prepend(header, data)
end
|
ruby
|
def store_defcol #:nodoc:
record = 0x0055 # Record identifier
length = 0x0002 # Number of bytes to follow
colwidth = 0x0008 # Default column width
header = [record, length].pack("vv")
data = [colwidth].pack("v")
prepend(header, data)
end
|
[
"def",
"store_defcol",
"#:nodoc:",
"record",
"=",
"0x0055",
"# Record identifier",
"length",
"=",
"0x0002",
"# Number of bytes to follow",
"colwidth",
"=",
"0x0008",
"# Default column width",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"\"vv\"",
")",
"data",
"=",
"[",
"colwidth",
"]",
".",
"pack",
"(",
"\"v\"",
")",
"prepend",
"(",
"header",
",",
"data",
")",
"end"
] |
Write BIFF record DEFCOLWIDTH.
|
[
"Write",
"BIFF",
"record",
"DEFCOLWIDTH",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L5619-L5628
|
19,088
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.store_autofilterinfo
|
def store_autofilterinfo #:nodoc:
# Only write the record if the worksheet contains an autofilter.
return '' if @filter_area.count == 0
record = 0x009D # Record identifier
length = 0x0002 # Number of bytes to follow
num_filters = @filter_area.count
header = [record, length].pack('vv')
data = [num_filters].pack('v')
prepend(header, data)
end
|
ruby
|
def store_autofilterinfo #:nodoc:
# Only write the record if the worksheet contains an autofilter.
return '' if @filter_area.count == 0
record = 0x009D # Record identifier
length = 0x0002 # Number of bytes to follow
num_filters = @filter_area.count
header = [record, length].pack('vv')
data = [num_filters].pack('v')
prepend(header, data)
end
|
[
"def",
"store_autofilterinfo",
"#:nodoc:",
"# Only write the record if the worksheet contains an autofilter.",
"return",
"''",
"if",
"@filter_area",
".",
"count",
"==",
"0",
"record",
"=",
"0x009D",
"# Record identifier",
"length",
"=",
"0x0002",
"# Number of bytes to follow",
"num_filters",
"=",
"@filter_area",
".",
"count",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"'vv'",
")",
"data",
"=",
"[",
"num_filters",
"]",
".",
"pack",
"(",
"'v'",
")",
"prepend",
"(",
"header",
",",
"data",
")",
"end"
] |
Write BIFF record AUTOFILTERINFO.
|
[
"Write",
"BIFF",
"record",
"AUTOFILTERINFO",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L5653-L5665
|
19,089
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.store_selection
|
def store_selection(first_row=0, first_col=0, last_row = nil, last_col =nil) #:nodoc:
record = 0x001D # Record identifier
length = 0x000F # Number of bytes to follow
pane_position = @active_pane # Pane position
row_active = first_row # Active row
col_active = first_col # Active column
irefAct = 0 # Active cell ref
cref = 1 # Number of refs
row_first = first_row # First row in reference
col_first = first_col # First col in reference
row_last = last_row || row_first # Last row in reference
col_last = last_col || col_first # Last col in reference
# Swap last row/col for first row/col as necessary
row_first, row_last = row_last, row_first if row_first > row_last
col_first, col_last = col_last, col_first if col_first > col_last
header = [record, length].pack('vv')
data = [pane_position, row_active, col_active, irefAct, cref,
row_first, row_last, col_first, col_last].pack('CvvvvvvCC')
append(header, data)
end
|
ruby
|
def store_selection(first_row=0, first_col=0, last_row = nil, last_col =nil) #:nodoc:
record = 0x001D # Record identifier
length = 0x000F # Number of bytes to follow
pane_position = @active_pane # Pane position
row_active = first_row # Active row
col_active = first_col # Active column
irefAct = 0 # Active cell ref
cref = 1 # Number of refs
row_first = first_row # First row in reference
col_first = first_col # First col in reference
row_last = last_row || row_first # Last row in reference
col_last = last_col || col_first # Last col in reference
# Swap last row/col for first row/col as necessary
row_first, row_last = row_last, row_first if row_first > row_last
col_first, col_last = col_last, col_first if col_first > col_last
header = [record, length].pack('vv')
data = [pane_position, row_active, col_active, irefAct, cref,
row_first, row_last, col_first, col_last].pack('CvvvvvvCC')
append(header, data)
end
|
[
"def",
"store_selection",
"(",
"first_row",
"=",
"0",
",",
"first_col",
"=",
"0",
",",
"last_row",
"=",
"nil",
",",
"last_col",
"=",
"nil",
")",
"#:nodoc:",
"record",
"=",
"0x001D",
"# Record identifier",
"length",
"=",
"0x000F",
"# Number of bytes to follow",
"pane_position",
"=",
"@active_pane",
"# Pane position",
"row_active",
"=",
"first_row",
"# Active row",
"col_active",
"=",
"first_col",
"# Active column",
"irefAct",
"=",
"0",
"# Active cell ref",
"cref",
"=",
"1",
"# Number of refs",
"row_first",
"=",
"first_row",
"# First row in reference",
"col_first",
"=",
"first_col",
"# First col in reference",
"row_last",
"=",
"last_row",
"||",
"row_first",
"# Last row in reference",
"col_last",
"=",
"last_col",
"||",
"col_first",
"# Last col in reference",
"# Swap last row/col for first row/col as necessary",
"row_first",
",",
"row_last",
"=",
"row_last",
",",
"row_first",
"if",
"row_first",
">",
"row_last",
"col_first",
",",
"col_last",
"=",
"col_last",
",",
"col_first",
"if",
"col_first",
">",
"col_last",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"'vv'",
")",
"data",
"=",
"[",
"pane_position",
",",
"row_active",
",",
"col_active",
",",
"irefAct",
",",
"cref",
",",
"row_first",
",",
"row_last",
",",
"col_first",
",",
"col_last",
"]",
".",
"pack",
"(",
"'CvvvvvvCC'",
")",
"append",
"(",
"header",
",",
"data",
")",
"end"
] |
Write BIFF record SELECTION.
|
[
"Write",
"BIFF",
"record",
"SELECTION",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L5670-L5694
|
19,090
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.store_externcount
|
def store_externcount(count) #:nodoc:
record = 0x0016 # Record identifier
length = 0x0002 # Number of bytes to follow
cxals = count # Number of external references
header = [record, length].pack('vv')
data = [cxals].pack('v')
prepend(header, data)
end
|
ruby
|
def store_externcount(count) #:nodoc:
record = 0x0016 # Record identifier
length = 0x0002 # Number of bytes to follow
cxals = count # Number of external references
header = [record, length].pack('vv')
data = [cxals].pack('v')
prepend(header, data)
end
|
[
"def",
"store_externcount",
"(",
"count",
")",
"#:nodoc:",
"record",
"=",
"0x0016",
"# Record identifier",
"length",
"=",
"0x0002",
"# Number of bytes to follow",
"cxals",
"=",
"count",
"# Number of external references",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"'vv'",
")",
"data",
"=",
"[",
"cxals",
"]",
".",
"pack",
"(",
"'v'",
")",
"prepend",
"(",
"header",
",",
"data",
")",
"end"
] |
Write BIFF record EXTERNCOUNT to indicate the number of external sheet
references in a worksheet.
Excel only stores references to external sheets that are used in formulas.
For simplicity we store references to all the sheets in the workbook
regardless of whether they are used or not. This reduces the overall
complexity and eliminates the need for a two way dialogue between the formula
parser the worksheet objects.
|
[
"Write",
"BIFF",
"record",
"EXTERNCOUNT",
"to",
"indicate",
"the",
"number",
"of",
"external",
"sheet",
"references",
"in",
"a",
"worksheet",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L5706-L5716
|
19,091
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.store_setup
|
def store_setup #:nodoc:
record = 0x00A1 # Record identifier
length = 0x0022 # Number of bytes to follow
iPaperSize = @paper_size # Paper size
iScale = @print_scale # Print scaling factor
iPageStart = @page_start # Starting page number
iFitWidth = @fit_width # Fit to number of pages wide
iFitHeight = @fit_height # Fit to number of pages high
grbit = 0x00 # Option flags
iRes = 0x0258 # Print resolution
iVRes = 0x0258 # Vertical print resolution
numHdr = @margin_header # Header Margin
numFtr = @margin_footer # Footer Margin
iCopies = 0x01 # Number of copies
fLeftToRight = @page_order # Print over then down
fLandscape = @orientation # Page orientation
fNoPls = 0x0 # Setup not read from printer
fNoColor = @black_white # Print black and white
fDraft = @draft_quality # Print draft quality
fNotes = @print_comments# Print notes
fNoOrient = 0x0 # Orientation not set
fUsePage = @custom_start # Use custom starting page
grbit = fLeftToRight
grbit |= fLandscape << 1
grbit |= fNoPls << 2
grbit |= fNoColor << 3
grbit |= fDraft << 4
grbit |= fNotes << 5
grbit |= fNoOrient << 6
grbit |= fUsePage << 7
numHdr = [numHdr].pack('d')
numFtr = [numFtr].pack('d')
if @byte_order
numHdr.reverse!
numFtr.reverse!
end
header = [record, length].pack('vv')
data1 = [iPaperSize, iScale, iPageStart,
iFitWidth, iFitHeight, grbit, iRes, iVRes].pack("vvvvvvvv")
data2 = numHdr + numFtr
data3 = [iCopies].pack('v')
prepend(header, data1, data2, data3)
end
|
ruby
|
def store_setup #:nodoc:
record = 0x00A1 # Record identifier
length = 0x0022 # Number of bytes to follow
iPaperSize = @paper_size # Paper size
iScale = @print_scale # Print scaling factor
iPageStart = @page_start # Starting page number
iFitWidth = @fit_width # Fit to number of pages wide
iFitHeight = @fit_height # Fit to number of pages high
grbit = 0x00 # Option flags
iRes = 0x0258 # Print resolution
iVRes = 0x0258 # Vertical print resolution
numHdr = @margin_header # Header Margin
numFtr = @margin_footer # Footer Margin
iCopies = 0x01 # Number of copies
fLeftToRight = @page_order # Print over then down
fLandscape = @orientation # Page orientation
fNoPls = 0x0 # Setup not read from printer
fNoColor = @black_white # Print black and white
fDraft = @draft_quality # Print draft quality
fNotes = @print_comments# Print notes
fNoOrient = 0x0 # Orientation not set
fUsePage = @custom_start # Use custom starting page
grbit = fLeftToRight
grbit |= fLandscape << 1
grbit |= fNoPls << 2
grbit |= fNoColor << 3
grbit |= fDraft << 4
grbit |= fNotes << 5
grbit |= fNoOrient << 6
grbit |= fUsePage << 7
numHdr = [numHdr].pack('d')
numFtr = [numFtr].pack('d')
if @byte_order
numHdr.reverse!
numFtr.reverse!
end
header = [record, length].pack('vv')
data1 = [iPaperSize, iScale, iPageStart,
iFitWidth, iFitHeight, grbit, iRes, iVRes].pack("vvvvvvvv")
data2 = numHdr + numFtr
data3 = [iCopies].pack('v')
prepend(header, data1, data2, data3)
end
|
[
"def",
"store_setup",
"#:nodoc:",
"record",
"=",
"0x00A1",
"# Record identifier",
"length",
"=",
"0x0022",
"# Number of bytes to follow",
"iPaperSize",
"=",
"@paper_size",
"# Paper size",
"iScale",
"=",
"@print_scale",
"# Print scaling factor",
"iPageStart",
"=",
"@page_start",
"# Starting page number",
"iFitWidth",
"=",
"@fit_width",
"# Fit to number of pages wide",
"iFitHeight",
"=",
"@fit_height",
"# Fit to number of pages high",
"grbit",
"=",
"0x00",
"# Option flags",
"iRes",
"=",
"0x0258",
"# Print resolution",
"iVRes",
"=",
"0x0258",
"# Vertical print resolution",
"numHdr",
"=",
"@margin_header",
"# Header Margin",
"numFtr",
"=",
"@margin_footer",
"# Footer Margin",
"iCopies",
"=",
"0x01",
"# Number of copies",
"fLeftToRight",
"=",
"@page_order",
"# Print over then down",
"fLandscape",
"=",
"@orientation",
"# Page orientation",
"fNoPls",
"=",
"0x0",
"# Setup not read from printer",
"fNoColor",
"=",
"@black_white",
"# Print black and white",
"fDraft",
"=",
"@draft_quality",
"# Print draft quality",
"fNotes",
"=",
"@print_comments",
"# Print notes",
"fNoOrient",
"=",
"0x0",
"# Orientation not set",
"fUsePage",
"=",
"@custom_start",
"# Use custom starting page",
"grbit",
"=",
"fLeftToRight",
"grbit",
"|=",
"fLandscape",
"<<",
"1",
"grbit",
"|=",
"fNoPls",
"<<",
"2",
"grbit",
"|=",
"fNoColor",
"<<",
"3",
"grbit",
"|=",
"fDraft",
"<<",
"4",
"grbit",
"|=",
"fNotes",
"<<",
"5",
"grbit",
"|=",
"fNoOrient",
"<<",
"6",
"grbit",
"|=",
"fUsePage",
"<<",
"7",
"numHdr",
"=",
"[",
"numHdr",
"]",
".",
"pack",
"(",
"'d'",
")",
"numFtr",
"=",
"[",
"numFtr",
"]",
".",
"pack",
"(",
"'d'",
")",
"if",
"@byte_order",
"numHdr",
".",
"reverse!",
"numFtr",
".",
"reverse!",
"end",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"'vv'",
")",
"data1",
"=",
"[",
"iPaperSize",
",",
"iScale",
",",
"iPageStart",
",",
"iFitWidth",
",",
"iFitHeight",
",",
"grbit",
",",
"iRes",
",",
"iVRes",
"]",
".",
"pack",
"(",
"\"vvvvvvvv\"",
")",
"data2",
"=",
"numHdr",
"+",
"numFtr",
"data3",
"=",
"[",
"iCopies",
"]",
".",
"pack",
"(",
"'v'",
")",
"prepend",
"(",
"header",
",",
"data1",
",",
"data2",
",",
"data3",
")",
"end"
] |
Store the page setup SETUP BIFF record.
|
[
"Store",
"the",
"page",
"setup",
"SETUP",
"BIFF",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L5807-L5859
|
19,092
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.store_gridset
|
def store_gridset #:nodoc:
record = 0x0082 # Record identifier
length = 0x0002 # Bytes to follow
fGridSet = @print_gridlines == 0 ? 1 : 0 # Boolean flag
header = [record, length].pack("vv")
data = [fGridSet].pack("v")
prepend(header, data)
end
|
ruby
|
def store_gridset #:nodoc:
record = 0x0082 # Record identifier
length = 0x0002 # Bytes to follow
fGridSet = @print_gridlines == 0 ? 1 : 0 # Boolean flag
header = [record, length].pack("vv")
data = [fGridSet].pack("v")
prepend(header, data)
end
|
[
"def",
"store_gridset",
"#:nodoc:",
"record",
"=",
"0x0082",
"# Record identifier",
"length",
"=",
"0x0002",
"# Bytes to follow",
"fGridSet",
"=",
"@print_gridlines",
"==",
"0",
"?",
"1",
":",
"0",
"# Boolean flag",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"\"vv\"",
")",
"data",
"=",
"[",
"fGridSet",
"]",
".",
"pack",
"(",
"\"v\"",
")",
"prepend",
"(",
"header",
",",
"data",
")",
"end"
] |
Write the GRIDSET BIFF record. Must be used in conjunction with the
PRINTGRIDLINES record.
|
[
"Write",
"the",
"GRIDSET",
"BIFF",
"record",
".",
"Must",
"be",
"used",
"in",
"conjunction",
"with",
"the",
"PRINTGRIDLINES",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L6032-L6042
|
19,093
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.store_wsbool
|
def store_wsbool #:nodoc:
record = 0x0081 # Record identifier
length = 0x0002 # Bytes to follow
grbit = 0x0000 # Option flags
# Set the option flags
grbit |= 0x0001 # Auto page breaks visible
grbit |= 0x0020 if @outline.style != 0 # Auto outline styles
grbit |= 0x0040 if @outline.below != 0 # Outline summary below
grbit |= 0x0080 if @outline.right != 0 # Outline summary right
grbit |= 0x0100 if @fit_page != 0 # Page setup fit to page
grbit |= 0x0400 if @outline.visible? # Outline symbols displayed
header = [record, length].pack("vv")
data = [grbit].pack('v')
prepend(header, data)
end
|
ruby
|
def store_wsbool #:nodoc:
record = 0x0081 # Record identifier
length = 0x0002 # Bytes to follow
grbit = 0x0000 # Option flags
# Set the option flags
grbit |= 0x0001 # Auto page breaks visible
grbit |= 0x0020 if @outline.style != 0 # Auto outline styles
grbit |= 0x0040 if @outline.below != 0 # Outline summary below
grbit |= 0x0080 if @outline.right != 0 # Outline summary right
grbit |= 0x0100 if @fit_page != 0 # Page setup fit to page
grbit |= 0x0400 if @outline.visible? # Outline symbols displayed
header = [record, length].pack("vv")
data = [grbit].pack('v')
prepend(header, data)
end
|
[
"def",
"store_wsbool",
"#:nodoc:",
"record",
"=",
"0x0081",
"# Record identifier",
"length",
"=",
"0x0002",
"# Bytes to follow",
"grbit",
"=",
"0x0000",
"# Option flags",
"# Set the option flags",
"grbit",
"|=",
"0x0001",
"# Auto page breaks visible",
"grbit",
"|=",
"0x0020",
"if",
"@outline",
".",
"style",
"!=",
"0",
"# Auto outline styles",
"grbit",
"|=",
"0x0040",
"if",
"@outline",
".",
"below",
"!=",
"0",
"# Outline summary below",
"grbit",
"|=",
"0x0080",
"if",
"@outline",
".",
"right",
"!=",
"0",
"# Outline summary right",
"grbit",
"|=",
"0x0100",
"if",
"@fit_page",
"!=",
"0",
"# Page setup fit to page",
"grbit",
"|=",
"0x0400",
"if",
"@outline",
".",
"visible?",
"# Outline symbols displayed",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"\"vv\"",
")",
"data",
"=",
"[",
"grbit",
"]",
".",
"pack",
"(",
"'v'",
")",
"prepend",
"(",
"header",
",",
"data",
")",
"end"
] |
Write the WSBOOL BIFF record, mainly for fit-to-page. Used in conjunction
with the SETUP record.
|
[
"Write",
"the",
"WSBOOL",
"BIFF",
"record",
"mainly",
"for",
"fit",
"-",
"to",
"-",
"page",
".",
"Used",
"in",
"conjunction",
"with",
"the",
"SETUP",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L6083-L6101
|
19,094
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.store_password
|
def store_password #:nodoc:
# Exit unless sheet protection and password have been specified
return unless protect? && @password
record = 0x0013 # Record identifier
length = 0x0002 # Bytes to follow
wPassword = @password # Encoded password
header = [record, length].pack("vv")
data = [wPassword].pack("v")
prepend(header, data)
end
|
ruby
|
def store_password #:nodoc:
# Exit unless sheet protection and password have been specified
return unless protect? && @password
record = 0x0013 # Record identifier
length = 0x0002 # Bytes to follow
wPassword = @password # Encoded password
header = [record, length].pack("vv")
data = [wPassword].pack("v")
prepend(header, data)
end
|
[
"def",
"store_password",
"#:nodoc:",
"# Exit unless sheet protection and password have been specified",
"return",
"unless",
"protect?",
"&&",
"@password",
"record",
"=",
"0x0013",
"# Record identifier",
"length",
"=",
"0x0002",
"# Bytes to follow",
"wPassword",
"=",
"@password",
"# Encoded password",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"\"vv\"",
")",
"data",
"=",
"[",
"wPassword",
"]",
".",
"pack",
"(",
"\"v\"",
")",
"prepend",
"(",
"header",
",",
"data",
")",
"end"
] |
Write the worksheet PASSWORD record.
|
[
"Write",
"the",
"worksheet",
"PASSWORD",
"record",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L6175-L6188
|
19,095
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.store_table
|
def store_table #:nodoc:
return unless compatibility?
# Offset from the DBCELL record back to the first ROW of the 32 row block.
row_offset = 0
# Track rows that have cell data or modified by set_row().
written_rows = []
# Write the ROW records with updated max/min col fields.
#
(0 .. @dimension.row_max-1).each do |row|
# Skip unless there is cell data in row or the row has been modified.
next unless @table[row] or @row_data[row]
# Store the rows with data.
written_rows.push(row)
# Increase the row offset by the length of a ROW record;
row_offset += 20
# The max/min cols in the ROW records are the same as in DIMENSIONS.
col_min = @dimension.col_min
col_max = @dimension.col_max
# Write a user specified ROW record (modified by set_row()).
if @row_data[row]
# Rewrite the min and max cols for user defined row record.
packed_row = @row_data[row]
packed_row[6..9] = [col_min, col_max].pack('vv')
append(packed_row)
else
# Write a default Row record if there isn't a user defined ROW.
write_row_default(row, col_min, col_max)
end
# If 32 rows have been written or we are at the last row in the
# worksheet then write the cell data and the DBCELL record.
#
if written_rows.size == 32 || row == @dimension.row_max - 1
# Offsets to the first cell of each row.
cell_offsets = []
cell_offsets.push(row_offset - 20)
# Write the cell data in each row and sum their lengths for the
# cell offsets.
#
written_rows.each do |rw|
cell_offset = 0
if @table[rw]
@table[rw].each do |clm|
next unless clm
append(clm)
length = clm.bytesize
row_offset += length
cell_offset += length
end
end
cell_offsets.push(cell_offset)
end
# The last offset isn't required.
cell_offsets.pop
# Stores the DBCELL offset for use in the INDEX record.
@db_indices.push(@datasize)
# Write the DBCELL record.
store_dbcell(row_offset, cell_offsets)
# Clear the variable for the next block of rows.
written_rows = []
cell_offsets = []
row_offset = 0
end
end
end
|
ruby
|
def store_table #:nodoc:
return unless compatibility?
# Offset from the DBCELL record back to the first ROW of the 32 row block.
row_offset = 0
# Track rows that have cell data or modified by set_row().
written_rows = []
# Write the ROW records with updated max/min col fields.
#
(0 .. @dimension.row_max-1).each do |row|
# Skip unless there is cell data in row or the row has been modified.
next unless @table[row] or @row_data[row]
# Store the rows with data.
written_rows.push(row)
# Increase the row offset by the length of a ROW record;
row_offset += 20
# The max/min cols in the ROW records are the same as in DIMENSIONS.
col_min = @dimension.col_min
col_max = @dimension.col_max
# Write a user specified ROW record (modified by set_row()).
if @row_data[row]
# Rewrite the min and max cols for user defined row record.
packed_row = @row_data[row]
packed_row[6..9] = [col_min, col_max].pack('vv')
append(packed_row)
else
# Write a default Row record if there isn't a user defined ROW.
write_row_default(row, col_min, col_max)
end
# If 32 rows have been written or we are at the last row in the
# worksheet then write the cell data and the DBCELL record.
#
if written_rows.size == 32 || row == @dimension.row_max - 1
# Offsets to the first cell of each row.
cell_offsets = []
cell_offsets.push(row_offset - 20)
# Write the cell data in each row and sum their lengths for the
# cell offsets.
#
written_rows.each do |rw|
cell_offset = 0
if @table[rw]
@table[rw].each do |clm|
next unless clm
append(clm)
length = clm.bytesize
row_offset += length
cell_offset += length
end
end
cell_offsets.push(cell_offset)
end
# The last offset isn't required.
cell_offsets.pop
# Stores the DBCELL offset for use in the INDEX record.
@db_indices.push(@datasize)
# Write the DBCELL record.
store_dbcell(row_offset, cell_offsets)
# Clear the variable for the next block of rows.
written_rows = []
cell_offsets = []
row_offset = 0
end
end
end
|
[
"def",
"store_table",
"#:nodoc:",
"return",
"unless",
"compatibility?",
"# Offset from the DBCELL record back to the first ROW of the 32 row block.",
"row_offset",
"=",
"0",
"# Track rows that have cell data or modified by set_row().",
"written_rows",
"=",
"[",
"]",
"# Write the ROW records with updated max/min col fields.",
"#",
"(",
"0",
"..",
"@dimension",
".",
"row_max",
"-",
"1",
")",
".",
"each",
"do",
"|",
"row",
"|",
"# Skip unless there is cell data in row or the row has been modified.",
"next",
"unless",
"@table",
"[",
"row",
"]",
"or",
"@row_data",
"[",
"row",
"]",
"# Store the rows with data.",
"written_rows",
".",
"push",
"(",
"row",
")",
"# Increase the row offset by the length of a ROW record;",
"row_offset",
"+=",
"20",
"# The max/min cols in the ROW records are the same as in DIMENSIONS.",
"col_min",
"=",
"@dimension",
".",
"col_min",
"col_max",
"=",
"@dimension",
".",
"col_max",
"# Write a user specified ROW record (modified by set_row()).",
"if",
"@row_data",
"[",
"row",
"]",
"# Rewrite the min and max cols for user defined row record.",
"packed_row",
"=",
"@row_data",
"[",
"row",
"]",
"packed_row",
"[",
"6",
"..",
"9",
"]",
"=",
"[",
"col_min",
",",
"col_max",
"]",
".",
"pack",
"(",
"'vv'",
")",
"append",
"(",
"packed_row",
")",
"else",
"# Write a default Row record if there isn't a user defined ROW.",
"write_row_default",
"(",
"row",
",",
"col_min",
",",
"col_max",
")",
"end",
"# If 32 rows have been written or we are at the last row in the",
"# worksheet then write the cell data and the DBCELL record.",
"#",
"if",
"written_rows",
".",
"size",
"==",
"32",
"||",
"row",
"==",
"@dimension",
".",
"row_max",
"-",
"1",
"# Offsets to the first cell of each row.",
"cell_offsets",
"=",
"[",
"]",
"cell_offsets",
".",
"push",
"(",
"row_offset",
"-",
"20",
")",
"# Write the cell data in each row and sum their lengths for the",
"# cell offsets.",
"#",
"written_rows",
".",
"each",
"do",
"|",
"rw",
"|",
"cell_offset",
"=",
"0",
"if",
"@table",
"[",
"rw",
"]",
"@table",
"[",
"rw",
"]",
".",
"each",
"do",
"|",
"clm",
"|",
"next",
"unless",
"clm",
"append",
"(",
"clm",
")",
"length",
"=",
"clm",
".",
"bytesize",
"row_offset",
"+=",
"length",
"cell_offset",
"+=",
"length",
"end",
"end",
"cell_offsets",
".",
"push",
"(",
"cell_offset",
")",
"end",
"# The last offset isn't required.",
"cell_offsets",
".",
"pop",
"# Stores the DBCELL offset for use in the INDEX record.",
"@db_indices",
".",
"push",
"(",
"@datasize",
")",
"# Write the DBCELL record.",
"store_dbcell",
"(",
"row_offset",
",",
"cell_offsets",
")",
"# Clear the variable for the next block of rows.",
"written_rows",
"=",
"[",
"]",
"cell_offsets",
"=",
"[",
"]",
"row_offset",
"=",
"0",
"end",
"end",
"end"
] |
Note about compatibility mode.
Excel doesn't require every possible Biff record to be present in a file.
In particular if the indexing records INDEX, ROW and DBCELL aren't present
it just ignores the fact and reads the cells anyway. This is also true of
the EXTSST record. Gnumeric and OOo also take this approach. This allows
WriteExcel to ignore these records in order to minimise the amount of data
stored in memory. However, other third party applications that read Excel
files often expect these records to be present. In "compatibility mode"
WriteExcel writes these records and tries to be as close to an Excel
generated file as possible.
This requires additional data to be stored in memory until the file is
about to be written. This incurs a memory and speed penalty and may not be
suitable for very large files.
Write cell data stored in the worksheet row/col table.
This is only used when compatibity_mode() is in operation.
This method writes ROW data, then cell data (NUMBER, LABELSST, etc) and then
DBCELL records in blocks of 32 rows. This is explained in detail (for a
change) in the Excel SDK and in the OOo Excel file format doc.
|
[
"Note",
"about",
"compatibility",
"mode",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L6219-L6297
|
19,096
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.size_col
|
def size_col(col) #:nodoc:
# Look up the cell value to see if it has been changed
if @col_sizes[col]
width = @col_sizes[col]
# The relationship is different for user units less than 1.
if width < 1
(width *12).to_i
else
(width *7 +5 ).to_i
end
else
64
end
end
|
ruby
|
def size_col(col) #:nodoc:
# Look up the cell value to see if it has been changed
if @col_sizes[col]
width = @col_sizes[col]
# The relationship is different for user units less than 1.
if width < 1
(width *12).to_i
else
(width *7 +5 ).to_i
end
else
64
end
end
|
[
"def",
"size_col",
"(",
"col",
")",
"#:nodoc:",
"# Look up the cell value to see if it has been changed",
"if",
"@col_sizes",
"[",
"col",
"]",
"width",
"=",
"@col_sizes",
"[",
"col",
"]",
"# The relationship is different for user units less than 1.",
"if",
"width",
"<",
"1",
"(",
"width",
"12",
")",
".",
"to_i",
"else",
"(",
"width",
"7",
"+",
"5",
")",
".",
"to_i",
"end",
"else",
"64",
"end",
"end"
] |
Convert the width of a cell from user's units to pixels. Excel rounds the
column width to the nearest pixel. If the width hasn't been set by the user
we use the default value. If the column is hidden we use a value of zero.
|
[
"Convert",
"the",
"width",
"of",
"a",
"cell",
"from",
"user",
"s",
"units",
"to",
"pixels",
".",
"Excel",
"rounds",
"the",
"column",
"width",
"to",
"the",
"nearest",
"pixel",
".",
"If",
"the",
"width",
"hasn",
"t",
"been",
"set",
"by",
"the",
"user",
"we",
"use",
"the",
"default",
"value",
".",
"If",
"the",
"column",
"is",
"hidden",
"we",
"use",
"a",
"value",
"of",
"zero",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L6364-L6378
|
19,097
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.store_autofilter
|
def store_autofilter(index, operator_1, token_1, #:nodoc:
join = nil, operator_2 = nil, token_2 = nil)
record = 0x009E
length = 0x0000
top10_active = 0
top10_direction = 0
top10_percent = 0
top10_value = 101
grbit = join || 0
optimised_1 = 0
optimised_2 = 0
doper_1 = ''
doper_2 = ''
string_1 = ''
string_2 = ''
# Excel used an optimisation in the case of a simple equality.
optimised_1 = 1 if operator_1 == 2
optimised_2 = 1 if operator_2 && operator_2 == 2
# Convert non-simple equalities back to type 2. See parse_filter_tokens().
operator_1 = 2 if operator_1 == 22
operator_2 = 2 if operator_2 && operator_2 == 22
# Handle a "Top" style expression.
if operator_1 >= 30
# Remove the second expression if present.
operator_2 = nil
token_2 = nil
# Set the active flag.
top10_active = 1
if (operator_1 == 30 or operator_1 == 31)
top10_direction = 1
end
if (operator_1 == 31 or operator_1 == 33)
top10_percent = 1
end
if (top10_direction == 1)
operator_1 = 6
else
operator_1 = 3
end
top10_value = token_1.to_i
token_1 = 0
end
grbit |= optimised_1 << 2
grbit |= optimised_2 << 3
grbit |= top10_active << 4
grbit |= top10_direction << 5
grbit |= top10_percent << 6
grbit |= top10_value << 7
doper_1, string_1 = pack_doper(operator_1, token_1)
doper_2, string_2 = pack_doper(operator_2, token_2)
doper_1 = '' unless doper_1
doper_2 = '' unless doper_2
string_1 = '' unless string_1
string_2 = '' unless string_2
data = [index].pack('v')
data += [grbit].pack('v')
data += doper_1 + doper_2 + string_1 + string_2
length = data.bytesize
header = [record, length].pack('vv')
prepend(header, data)
end
|
ruby
|
def store_autofilter(index, operator_1, token_1, #:nodoc:
join = nil, operator_2 = nil, token_2 = nil)
record = 0x009E
length = 0x0000
top10_active = 0
top10_direction = 0
top10_percent = 0
top10_value = 101
grbit = join || 0
optimised_1 = 0
optimised_2 = 0
doper_1 = ''
doper_2 = ''
string_1 = ''
string_2 = ''
# Excel used an optimisation in the case of a simple equality.
optimised_1 = 1 if operator_1 == 2
optimised_2 = 1 if operator_2 && operator_2 == 2
# Convert non-simple equalities back to type 2. See parse_filter_tokens().
operator_1 = 2 if operator_1 == 22
operator_2 = 2 if operator_2 && operator_2 == 22
# Handle a "Top" style expression.
if operator_1 >= 30
# Remove the second expression if present.
operator_2 = nil
token_2 = nil
# Set the active flag.
top10_active = 1
if (operator_1 == 30 or operator_1 == 31)
top10_direction = 1
end
if (operator_1 == 31 or operator_1 == 33)
top10_percent = 1
end
if (top10_direction == 1)
operator_1 = 6
else
operator_1 = 3
end
top10_value = token_1.to_i
token_1 = 0
end
grbit |= optimised_1 << 2
grbit |= optimised_2 << 3
grbit |= top10_active << 4
grbit |= top10_direction << 5
grbit |= top10_percent << 6
grbit |= top10_value << 7
doper_1, string_1 = pack_doper(operator_1, token_1)
doper_2, string_2 = pack_doper(operator_2, token_2)
doper_1 = '' unless doper_1
doper_2 = '' unless doper_2
string_1 = '' unless string_1
string_2 = '' unless string_2
data = [index].pack('v')
data += [grbit].pack('v')
data += doper_1 + doper_2 + string_1 + string_2
length = data.bytesize
header = [record, length].pack('vv')
prepend(header, data)
end
|
[
"def",
"store_autofilter",
"(",
"index",
",",
"operator_1",
",",
"token_1",
",",
"#:nodoc:",
"join",
"=",
"nil",
",",
"operator_2",
"=",
"nil",
",",
"token_2",
"=",
"nil",
")",
"record",
"=",
"0x009E",
"length",
"=",
"0x0000",
"top10_active",
"=",
"0",
"top10_direction",
"=",
"0",
"top10_percent",
"=",
"0",
"top10_value",
"=",
"101",
"grbit",
"=",
"join",
"||",
"0",
"optimised_1",
"=",
"0",
"optimised_2",
"=",
"0",
"doper_1",
"=",
"''",
"doper_2",
"=",
"''",
"string_1",
"=",
"''",
"string_2",
"=",
"''",
"# Excel used an optimisation in the case of a simple equality.",
"optimised_1",
"=",
"1",
"if",
"operator_1",
"==",
"2",
"optimised_2",
"=",
"1",
"if",
"operator_2",
"&&",
"operator_2",
"==",
"2",
"# Convert non-simple equalities back to type 2. See parse_filter_tokens().",
"operator_1",
"=",
"2",
"if",
"operator_1",
"==",
"22",
"operator_2",
"=",
"2",
"if",
"operator_2",
"&&",
"operator_2",
"==",
"22",
"# Handle a \"Top\" style expression.",
"if",
"operator_1",
">=",
"30",
"# Remove the second expression if present.",
"operator_2",
"=",
"nil",
"token_2",
"=",
"nil",
"# Set the active flag.",
"top10_active",
"=",
"1",
"if",
"(",
"operator_1",
"==",
"30",
"or",
"operator_1",
"==",
"31",
")",
"top10_direction",
"=",
"1",
"end",
"if",
"(",
"operator_1",
"==",
"31",
"or",
"operator_1",
"==",
"33",
")",
"top10_percent",
"=",
"1",
"end",
"if",
"(",
"top10_direction",
"==",
"1",
")",
"operator_1",
"=",
"6",
"else",
"operator_1",
"=",
"3",
"end",
"top10_value",
"=",
"token_1",
".",
"to_i",
"token_1",
"=",
"0",
"end",
"grbit",
"|=",
"optimised_1",
"<<",
"2",
"grbit",
"|=",
"optimised_2",
"<<",
"3",
"grbit",
"|=",
"top10_active",
"<<",
"4",
"grbit",
"|=",
"top10_direction",
"<<",
"5",
"grbit",
"|=",
"top10_percent",
"<<",
"6",
"grbit",
"|=",
"top10_value",
"<<",
"7",
"doper_1",
",",
"string_1",
"=",
"pack_doper",
"(",
"operator_1",
",",
"token_1",
")",
"doper_2",
",",
"string_2",
"=",
"pack_doper",
"(",
"operator_2",
",",
"token_2",
")",
"doper_1",
"=",
"''",
"unless",
"doper_1",
"doper_2",
"=",
"''",
"unless",
"doper_2",
"string_1",
"=",
"''",
"unless",
"string_1",
"string_2",
"=",
"''",
"unless",
"string_2",
"data",
"=",
"[",
"index",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"[",
"grbit",
"]",
".",
"pack",
"(",
"'v'",
")",
"data",
"+=",
"doper_1",
"+",
"doper_2",
"+",
"string_1",
"+",
"string_2",
"length",
"=",
"data",
".",
"bytesize",
"header",
"=",
"[",
"record",
",",
"length",
"]",
".",
"pack",
"(",
"'vv'",
")",
"prepend",
"(",
"header",
",",
"data",
")",
"end"
] |
Function to write worksheet AUTOFILTER records. These contain 2 Biff Doper
structures to represent the 2 possible filter conditions.
|
[
"Function",
"to",
"write",
"worksheet",
"AUTOFILTER",
"records",
".",
"These",
"contain",
"2",
"Biff",
"Doper",
"structures",
"to",
"represent",
"the",
"2",
"possible",
"filter",
"conditions",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L6444-L6520
|
19,098
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.pack_doper
|
def pack_doper(operator, token) #:nodoc:
doper = ''
string = ''
# Return default doper for non-defined filters.
unless operator
return pack_unused_doper, string
end
if token.to_s =~ /^blanks|nonblanks$/i
doper = pack_blanks_doper(operator, token)
elsif operator == 2 or
!(token.to_s =~ /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/)
# Excel treats all tokens as strings if the operator is equality, =.
string = token.to_s
ruby_19 { string = convert_to_ascii_if_ascii(string) }
encoding = 0
length = string.bytesize
# Handle utf8 strings
if is_utf8?(string)
string = utf8_to_16be(string)
encodign = 1
end
string =
ruby_18 { [encoding].pack('C') + string } ||
ruby_19 { [encoding].pack('C') + string.force_encoding('BINARY') }
doper = pack_string_doper(operator, length)
else
string = ''
doper = pack_number_doper(operator, token)
end
[doper, string]
end
|
ruby
|
def pack_doper(operator, token) #:nodoc:
doper = ''
string = ''
# Return default doper for non-defined filters.
unless operator
return pack_unused_doper, string
end
if token.to_s =~ /^blanks|nonblanks$/i
doper = pack_blanks_doper(operator, token)
elsif operator == 2 or
!(token.to_s =~ /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/)
# Excel treats all tokens as strings if the operator is equality, =.
string = token.to_s
ruby_19 { string = convert_to_ascii_if_ascii(string) }
encoding = 0
length = string.bytesize
# Handle utf8 strings
if is_utf8?(string)
string = utf8_to_16be(string)
encodign = 1
end
string =
ruby_18 { [encoding].pack('C') + string } ||
ruby_19 { [encoding].pack('C') + string.force_encoding('BINARY') }
doper = pack_string_doper(operator, length)
else
string = ''
doper = pack_number_doper(operator, token)
end
[doper, string]
end
|
[
"def",
"pack_doper",
"(",
"operator",
",",
"token",
")",
"#:nodoc:",
"doper",
"=",
"''",
"string",
"=",
"''",
"# Return default doper for non-defined filters.",
"unless",
"operator",
"return",
"pack_unused_doper",
",",
"string",
"end",
"if",
"token",
".",
"to_s",
"=~",
"/",
"/i",
"doper",
"=",
"pack_blanks_doper",
"(",
"operator",
",",
"token",
")",
"elsif",
"operator",
"==",
"2",
"or",
"!",
"(",
"token",
".",
"to_s",
"=~",
"/",
"\\d",
"\\.",
"\\d",
"\\d",
"\\.",
"\\d",
"\\d",
"/",
")",
"# Excel treats all tokens as strings if the operator is equality, =.",
"string",
"=",
"token",
".",
"to_s",
"ruby_19",
"{",
"string",
"=",
"convert_to_ascii_if_ascii",
"(",
"string",
")",
"}",
"encoding",
"=",
"0",
"length",
"=",
"string",
".",
"bytesize",
"# Handle utf8 strings",
"if",
"is_utf8?",
"(",
"string",
")",
"string",
"=",
"utf8_to_16be",
"(",
"string",
")",
"encodign",
"=",
"1",
"end",
"string",
"=",
"ruby_18",
"{",
"[",
"encoding",
"]",
".",
"pack",
"(",
"'C'",
")",
"+",
"string",
"}",
"||",
"ruby_19",
"{",
"[",
"encoding",
"]",
".",
"pack",
"(",
"'C'",
")",
"+",
"string",
".",
"force_encoding",
"(",
"'BINARY'",
")",
"}",
"doper",
"=",
"pack_string_doper",
"(",
"operator",
",",
"length",
")",
"else",
"string",
"=",
"''",
"doper",
"=",
"pack_number_doper",
"(",
"operator",
",",
"token",
")",
"end",
"[",
"doper",
",",
"string",
"]",
"end"
] |
Create a Biff Doper structure that represents a filter expression. Depending
on the type of the token we pack an Empty, String or Number doper.
|
[
"Create",
"a",
"Biff",
"Doper",
"structure",
"that",
"represents",
"a",
"filter",
"expression",
".",
"Depending",
"on",
"the",
"type",
"of",
"the",
"token",
"we",
"pack",
"an",
"Empty",
"String",
"or",
"Number",
"doper",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L6526-L6562
|
19,099
|
cxn03651/writeexcel
|
lib/writeexcel/worksheet.rb
|
Writeexcel.Worksheet.pack_number_doper
|
def pack_number_doper(operator, number) #:nodoc:
number = [number].pack('d')
number.reverse! if @byte_order
[0x04, operator].pack('CC') + number
end
|
ruby
|
def pack_number_doper(operator, number) #:nodoc:
number = [number].pack('d')
number.reverse! if @byte_order
[0x04, operator].pack('CC') + number
end
|
[
"def",
"pack_number_doper",
"(",
"operator",
",",
"number",
")",
"#:nodoc:",
"number",
"=",
"[",
"number",
"]",
".",
"pack",
"(",
"'d'",
")",
"number",
".",
"reverse!",
"if",
"@byte_order",
"[",
"0x04",
",",
"operator",
"]",
".",
"pack",
"(",
"'CC'",
")",
"+",
"number",
"end"
] |
Pack an IEEE double number Doper structure.
|
[
"Pack",
"an",
"IEEE",
"double",
"number",
"Doper",
"structure",
"."
] |
d0345067c21b14a7141ba66b6752be8f4be379de
|
https://github.com/cxn03651/writeexcel/blob/d0345067c21b14a7141ba66b6752be8f4be379de/lib/writeexcel/worksheet.rb#L6604-L6609
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.